CN107967152A - 基于最小分支路径函数胎记的软件局部抄袭证据生成方法 - Google Patents

Abstract

本发明公开一种基于最小分支路径函数胎记的软件局部抄袭证据生成方法，通过对程序进行逆向分析，提取出程序的静态信息；基于函数的控制流图、基本块、指令序列等，提取基于最小分支路径的函数胎记，以表征函数的行为特征；计算函数胎记之间的相似度，从而得到函数之间的相似性；基于函数间的相似度，结合函数调用图，构建出最优相似子图集，将其作为程序间局部抄袭的判断依据和有力的抄袭证据，为真实的软件侵权案件提供初步证据。

Description

基于最小分支路径函数胎记的软件局部抄袭证据生成方法

技术领域

本发明涉及程序特征发现及软件抄袭检测领域，特别涉及一种软件局部抄袭证据生成的方法。

背景技术

随着计算机软件产业迅速发展，软件的安全问题得到了越来越多的研究人员、教育人员及软件企业的重视。而开源软件的出现，更是将软件抄袭问题推到了风头浪尖。近年来，各类软件侵权案件时有发生，Verizon、eBay、Apple等公司都曾卷入相关案件当中。

为了对抗软件抄袭，保护软件知识产权，国内外的研究人员提出了大量的软件抄袭检测技术。以应用场景和技术手段作为基准，可将现有的软件抄袭检测技术归为三类:源码抄袭检测技术，基于软件水印的抄袭检测技术，以及基于软件胎记的抄袭检测技术。

但是，目前的软件抄袭检测技术存在一系列的局限性：

1)目前大部分具有权威性的软件抄袭检测方法是针对源代码的，而在现实中，软件所有者通常是以二进制文件的形式发布软件，软件源代码在未取得一定的证据之前是很难获取；

2)抄袭者为了躲避软件抄袭检测，通常使用成熟、强力的代码混淆技术和工具，使得抄袭程序与原程序在表面上呈现很大的不同，使得一部分软件抄袭检测方法失效；

3)相较于整体抄袭，局部抄袭更为普遍，一方面是因为局部抄袭更容易符合抄袭者的要求，更加灵活，另一方面也因为使得计算出的软件与原版本之间的整体相似度较低，从而导致许多整体检测方法失效。

4)现有的抄袭检测都只是提供一个简单的结果，没有具体且有力的抄袭证据作为佐证。

发明内容

本发明的目的在于提出一种基于最小分支路径函数胎记的软件局部抄袭证据生成方法，以应对当前的软件抄袭检测的需要。本发明通过对程序进行逆向分析，提取出程序的静态信息；基于函数的控制流图、基本块、指令序列等，提取基于最小分支路径的函数胎记，以表征函数的行为特征；计算函数胎记之间的相似度，从而得到函数之间的相似性；基于函数间的相似度，结合函数调用图，构建出最优相似子图集，将其作为程序间局部抄袭的判断依据和有力的抄袭证据，为真实的软件侵权案件提供初步证据。

为了实现上述目的，本发明采用以下技术方案：

基于最小分支路径函数胎记的软件局部抄袭证据生成方法，包括如下步骤：

步骤S101：基于反汇编技术，对原告程序P及被告程序Q对应的可执行二进制文件进行反汇编，记录并分析生成的汇编代码，对于其包含的静态信息进行预处理并以数据表的形式存储；

步骤S102：基于程序的函数内静态控制流图，将一个分支的起始基本块到下一个分支的起始基本块之间的基本块所包含的指令序列作为函数的一条最小分支路径，一个函数F_id的函数胎记FB_id是其所有最小分支路径构成的集合PATH＝{path_id,i|i＝0,1,…n}，提取原告程序P与被告程序Q内所有函数对应的函数胎记PB＝{FB_i|i＝0,1,…,m₁}以及QB＝{FB_j'|j＝0,1,…,m₂}；n为函数胎记FB_id的所有最小分支路径的个数，m₁和m₂分别为原告程序P与被告程序Q中所有函数胎记的个数；

步骤S103：基于原告程序P内的所有函数胎记，计算其对于被告程序Q内的所有函数的函数胎记相似度SIM(FB_i,FB_j'),FB_i∈PB&&FB_j'∈QB；

步骤S104：基于函数间的相似度以及函数间调用图，发现相似子图集，构建最优相似子图集；

步骤S105：基于最优相似子图集，进行抄袭判定，如存在抄袭，生成抄袭证据。根据最优相似子图集的规模大小，并与原程序规模作比较从而判断程序是否存在抄袭，而生成的最优相似子图集则可作为被告程序Q抄袭原告程序P的抄袭证据。如果存在抄袭，将步骤S104获得的最优相似子图集输出作为抄袭证据。

进一步的，所述步骤S101具体为使用逆向分析工具来撤除编译和汇编过程，输入为机器语言，输出结果为汇编语言；对原告及被告程序P，Q对应的二进制可执行文件进行反汇编，对反汇编后输出的汇编代码进行分析，对程序包含的静态信息进行预处理，删除库函数以及过小的函数，得到有效的函数信息，以数据表的形式记录存储，存储方式如下表所示；

表名	表结构
		Functions	address#name#type
BasicBlocks	id#parent_function#adress
		BasicBlocks_Instructions	basicblock_id#instruction_address
Instructions	address#mnemonic
		Operands	address#expression_tree_id
Expression_Tree_Nodes	expression_tree_id#expression_node_id
		Expression_Nodes	id#type#symbol#immediate#parent_id
Control_Flow_Graphs	id#parent_function#source#destination
		Callgraph	id#source#destination

所述静态信息具体包括：基本块，函数，指令，助记符，操作数，函数内静态控制流图以及函数间调用图；

所述过小的函数为指令数小于3的函数。

进一步的，步骤S102中基于最小分支路径的函数胎记FB_id即最小分支路径集合PATH的提取方法是基于函数的静态控制流图，对函数内的每一个基本块b_id进行分析，如果该基本块的分支大于等于2或该基本块为所属函数的起始基本块，则提取以该基本块为起点的所有最小分支路径集合PATH_id＝{path_id,i|i＝0,1,…,m},并将该集合加入所属函数胎记集合，PATH＝PATH∪PATH_id，m为以基本块b_id为起点的所有最小分支路径的个数。

进一步的，步骤S102中提取基本块b_id的最小分支路径的方法是为其每一个分支创建一条以b_id为起点的路径path_id,i，对于每一条路径，将其后继基本块不断加入该路径中，直至遇到下一个分支，则该路径经过的基本块内的汇编指令构成了该最小分支路径，这些路径的集合PATH_id即为以该基本块为起点的所有最小分支路径。

进一步的，步骤S102中提取基本块中汇编指令的方法是：首先读取汇编指令的助记符，接着读取该汇编指令对应的操作数的表达树id，根据表达树id读取对应的节点id，从而读取节点id对应的符号或立即数，遍历该表达树的各个节点，得到操作数，最后将助记符与操作数组合，得到该汇编指令的表达形式。

进一步的，步骤S103中函数胎记之间相似度的计算方法是：令原告程序P中的函数Fun_1的胎记FB₁与被告程序Q中函数Fun_2的胎记FB₂'分别表示为PATH₁＝{path_1,i|i＝0,1,…,a}，PATH₂＝{path_2,j|j＝0,1,…,b}，a为函数Fun_1的函数胎记的所有最小分支路径的个数；b为函数Fun_2的函数胎记的所有最小分支路径的个数；对于PATH₁中的每一条路径path_1,i，计算其与PATH₂中每一条路径path_2,j的相似度，基于这些相似度，寻找与path_1,i最匹配的路径path_2,match，并记录其相似度sim(path_1,i,path_2,match)；基于Fun_1的静态信息，以路径中包含的汇编指令个数l_i为权值，进行加权计算，从而得到函数胎记FB₁与函数胎记FB₂之间的相似度，计算公式为：

式中：

l_i——函数Fun_1中第i条最小分支路径包含的汇编指令的个数；

则函数之间的相似度SIM(Fun_1,Fun_2)＝SIM(FB₁,FB₂')。

进一步的，步骤S103中路径path_1,i与path_2,j之间相似度的计算方法分为四个步骤，分别是预处理，校准路径，基于助记符和操作数关联的汇编指令相似值计算，以及路径相似度计算；具体如下：

a)预处理：预处理的方法是首先删除路径中所包含的跳转指令，接着将操作数抽象化；操作数抽象化是指将构成路径的指令中的具体操作数抽象为三类：寄存器，存储单元以及变量名，分别用REG，MEM，VAL来表示；

b)校准路径：校准路径的方法是使用LCS算法，以相同的助记符作为基准，对要进行相似性计算的两条路径path_1,i,path_2,j进行校准；校准后的两条路径为path_1,i',path_2,j'，这两条路径汇编指令的数目是相同的，同时对应位置上的汇编指令的助记符也是相同的；

c)基于助记符和操作数关联的汇编指令相似值计算：令校准后的路径path_1,i',path_2,j'表示为path_1,i'＝<ins₁,ins₂,…,ins_n>,path_2,j'＝<ins₁',ins₂',…,ins_n'>,其中，n为每条路径的汇编指令的数目。计算path_1,i',path_2,j'之间的相似值，首先计算对应位置的汇编指令ins_pos,ins_pos'之间的相似值，计算方法为对应位置的相同操作数的个数：

sim_ins(ins_pos,ins_pos')＝|{i|args(ins_pos)[i]＝args(ins_pos')[i]}|

式中：

ins_pos,ins_pos'——两条汇编指令；

args(ins_pos)[i]——汇编指令ins_pos的第i个操作数；

d)路径相似度计算：将path_1,i'中汇编指令的相似值相加，得到path_1,i',path_2,j'之间的相似值score(path_1,i',path_2,j')；采用相同的方法，得到path_1,i，path_2,j与其自身的相似值score(path_1,i,path_1,i)与score(path_2,j,path_2,j)；最后，进行标准化，得到路径path_1,i，path_2,j之间的相似度；

进一步的，步骤S104中，相似子图是指以函数为节点，函数的调用关系为边，对应节点相似度较高且对相似的函数有相同的调用关系的子图；最优相似子图是指，对每个子图基于节点数目、对应节点相似值和节点权重赋予一个分数，分数最高的子图为该子图的最优相似子图；最优相似子图集是指每次加入一个最优相似子图所得到的集合{G₁→G₁',G₂→G₂',...,G_n→G_n'}，G₁,G₂,...G_n属于原告程序P，G₁',G₂',...G_n'属于被告程序Q，且G₁,G₂,...G_n不相交，G₁',G₂',...G_n'不相交；G_i→G_i'为一个相似子图，其中i＝1，2，…n。

进一步的，步骤S104中最优相似子图集发现的方法是：

1)筛选出相似度大于阈值ε₁的相似函数对：

FF＝{(Fun_i,Fun_j)|Fun_i∈P&&Fun_j∈Q&&SIM(Fun_i,Fun_j)>ε₁}；

2)基于函数间调用图，生成FF的相似子图集G，并计算每个子图的分数S；

子图分数S是指子图中所有函数对的相似度的和，计算公式为：

式中，n为子图中所有函数对的数目；

3)提取最优相似子图G_b，记录其分数S_b，并入最优相似子图集；

4)如果最优相似子图的分数大于ε₂，更新FF，将目前最优相似子图集中包含的函数对从FF中移除，FF＝FF-{(Fun_i,Fun_j)|Fun_i∈G_b||Fun_j∈G_b}，并跳转至步骤2)；否则，结束，并输出当前的最优相似子图集；

其中阈值ε₁的取值为0.5～1；ε₂的取值大于1小于第一个提取的最优相似子图G_b的分数S_b。

进一步的，步骤S104中生成FF的相似子图集G的方法是：

2.1)将FF＝{ff_i|i＝0,1,…,n}中的第一个函数对ff₀作为一个子图加入子图集G中；G＝{{ff₀}}；n为FF中函数对的个数；

2.2)从ff_i，i＝1开始，遍历FF，对于ff_i：

a)遍历子图集G＝{G_j|j＝0,1,…,m}；m为子图集G中的子图个数；

b)如果ff_i与G_j不冲突，且基于函数调用图，对于ff_i，存在G_j中的函数对与其符合调用关系，则G＝G∪{G_j∪{ff_i}}；

2.3)将函数对ff_i作为一个子图加入子图集G中，G＝G∪{{ff_i}}；

2.4)输出相似子图集G；

步骤S104中判断一个函数对ff_i＝(Fun_i,Fun_i')是否与子图G_j冲突的方法是：如果存在ff＝(Fun,Fun')∈G_j，使得Fun_i＝Fun且Fun_i'≠Fun'，或Fun_i'＝Fun'且Fun_i≠Fun，则函数对ff_i与子图G_j冲突。

本发明的进一步改进在于：步骤S102具体包括以下步骤：

步骤S201：初始化最小分支路径的集合以及计数器id＝0；

步骤S202：从函数内静态控制流图中读取基本块b_id的内容；

步骤S203：判断是否计数器id＝＝0或b_id的分支数目大于等于2，若是，则转入步骤S204，否则转入步骤S206；

步骤S204：提取以基本块b_id为起点的所有最小分支路径集合PATH_id＝{path_id,i|i＝0,1,…,m}，并将该集合加入所属函数胎记集合，PATH＝PATH∪PATH_id；m为以基本块b_id为起点的所有最小分支路径的个数；

步骤S205：判断是否计数器id＝＝n，若是，则转入步骤S207，否则转入步骤S206；

步骤S206：计数器id++，并转入步骤S202进行下一轮的分析；

步骤S207：输出最小分支路径的集合PATH作为函数F的函数胎记FB。

本发明的进一步改进在于：步骤S102具体包括以下步骤：

步骤S301：输入基本块b_id及其m+1个后继基本块b_id,0,b_id,1,...b_id,m；

步骤S302：初始化b_id的最小分支路径的集合以及计数器i＝0；

步骤S303：为其后继基本块b_id,i创建一条以b_id为起点的路径path_id,i，path_id,i＝b_id+b_id,i；

步骤S304：创建指针pt指向当前后继基本块b_id,i，pt→b_id,i；

步骤S305：判断指针pt指向的基本块是否有且只有一个后继基本块pt.b_s，若是，则转入步骤S306，否则转入步骤S307；

步骤S306：将后继基本块pt.b_s加入路径path_id,i中，path_id,i＝path_id,i+pt.b_s，指针pt指向其后继基本块pt.b_s，pt→pt.b_s，并转入步骤S305进行下一轮的分析；

步骤S307：将当前路径path_id,i并入b_id的最小分支路径的集合PATH_id来，PATH_id＝PATH_id∪{path_id,i}，计数器i++；

步骤S308：判断是否计数器i>m，若是，则转入步骤S309，否则转入步骤S303进行下一轮的分析；

步骤S309：输出基本块b_id的所有最小分支路径集合PATH_id。

本发明的进一步改进在于：步骤S103具体包括以下步骤：

步骤S401：初始化计数器i＝0；

步骤S402：从函数Fun_1的函数胎记PATH₁＝{path_1,i|i＝0,1,…,a}中读取最小分支路径path_1,i；a为函数Fun_1的函数胎记的所有最小分支路径的个数；

步骤S403：读取函数Fun_2的函数胎记PATH₂＝{path_2,j|j＝0,1,…,b}，计算path_1,i与PATH₂中每一条路径path_2,j的相似度；b为函数Fun_2的函数胎记的所有最小分支路径的个数；

步骤S404：寻找与path_1,i最匹配的路径path_2,match，并记录其相似度sim(path_1,i,path_2,match)，存入路径间相似度矩阵SIM_Path中，SIM_Path＝[sim(path_1,i,path_2,match)],i＝0,1,…,a；

步骤S405：判断是否计数器i＝＝a，若是，则转入步骤S407，否则转入步骤S406；

步骤S406：计数器i++，并转入步骤S402进行下一轮的分析；

步骤S407：基于路径间相似度矩阵SIM_Path以及从函数胎记PATH₁中读取的Fun_1的静态信息，以路径中包含的汇编指令个数l_i为权值，进行加权计算，计算公式为：

式中：

l_i——函数Fun_1中第i条最小分支路径包含的汇编指令的个数；

步骤S408：输出函数Fun_1与函数Fun_2之间的相似度SIM(Fun_1,Fun_2)＝SIM(FB₁,FB₂')，并存入函数间相似度矩阵SIM_Fun中，SIM_Fun＝[SIM(Fun_i,Fun_j)],i＝0,1,…,m₁,j＝0,1,…,m₂。

本发明的进一步改进在于：步骤S103中路径path_1,i与path_2,j之间相似度的计算方法可分为四个步骤，分别是预处理，校准路径，基于助记符和操作数关联的汇编指令相似值计算，以及路径相似度计算。具体包括以下步骤：

步骤S501：输入最小分支路径path_1,i与path_2,j；

步骤S502：对路径path_1,i和path_2,j进行预处理，首先删除路径中所包含的跳转指令(包括JE、JNE、JZ、JNZ、JS、JNS、JC、JNC、JO、JNO、JA、JNA、JAE、JNAE、JG、JNG、JGE、JNGE、JB、JNB、JBE、JNBE、JL、JNL、JLE、JNLE、JP、JNP、JPE、JPO等跳转指令)；接着抽象化操作数，将构成路径的指令中的具体操作数抽象为三类：寄存器，存储单元以及变量名，分别用REG，MEM，VAL来表示；

步骤S503：使用LCS算法校准路径，以相同的助记符作为基准，对要进行相似性计算的两条路径path_1,i,path_2,j进行校准。校准后的两条路径为path_1,i',path_2,j'，这两条路径汇编指令的数目是相同的，同时对应位置上的汇编指令的助记符也是相同的；

步骤S504：基于助记符和操作数关联的汇编指令相似值计算，令校准后的路径path_1,i',path_2,j'表示为path_1,i'＝<ins₁,ins₂,…,ins_n>,path_2,j'＝<ins₁',ins₂',…,ins_n'>,其中，n为每条路径的汇编指令的数目。计算path_1,i',path_2,j'之间的相似值，首先计算对应位置的汇编指令ins_pos,ins_pos'之间的相似值，计算方法为取对应位置的相同操作数的个数，令ins_pos,ins_pos'表示两条汇编指令，args(ins_pos)[i]表示汇编指令ins_pos的第i个操作数，计算公式为：

sim(ins_pos,ins_pos')＝|{i|args(ins_pos)[i]＝args(ins_pos')[i]}|

式中：

ins_pos,ins_pos'——两条汇编指令；

args(ins_pos)[i]——汇编指令ins_pos的第i个操作数；

步骤S505：进行路径相似度计算，将path_1,i'中汇编指令的相似值相加，得到path_1,i',path_2,j'之间的相似值score(path_1,i',path_2,j')，计算公式为采用相同的方法，得到path_1,i，path_2,j与其自身的相似值score(path_1,i,path_1,i)与score(path_2,j,path_2,j)。最后，进行标准化，得到路径path_1,i，path_2,j之间的相似度：

步骤S506：输出最小分支路径path_1,i与path_2,j间的相似度sim(path_1,i,path_2,j)。

本发明的进一步改进在于：步骤S104中最优相似子图集发现的方法具体包括以下步骤：

步骤S601：输入阈值ε₁和ε₂，ε₁用于筛选相似函数对，ε₂用于判断是否可以结束循环；其中阈值ε₁的取值为0.5～1；ε₂的取值大于1小于第一个提取的最优相似子图G_b的分数S_b；

步骤S602：基于函数间相似度矩阵SIM_Fun，筛选出相似度大于一定阈值ε₁的相似函数对FF：

FF＝{(Fun_i,Fun_j)|Fun_i∈P&&Fun_j∈Q&&SIM(Fun_i,Fun_j)>ε₁}；

步骤S603：基于函数间调用图，生成FF的相似子图集G，并计算子图分数S；

子图分数S是指子图中所有函数对的相似度的和，计算公式为：

式中，n为子图中所有函数对的数目；

步骤S604：提取最优相似子图G_b，记录其分数S_b，将其并入最优相似子图集；

步骤S605：判断是否当前最优相似子图集的分数S_b>ε₂，若是，则转入步骤S606，否则转入步骤S607；

步骤S606：更新FF，将目前最优相似子图集中包含的函数对从FF中移除，FF＝FF-{(Fun_i,Fun_j)|Fun_i∈G_b||Fun_j∈G_b}，并跳转至步骤S603进行下一轮的分析；

步骤S607：输出当前的最优相似子图集。

本发明的进一步改进在于：步骤S104中生成FF的相似子图集G的方法具体包括以下步骤：

步骤S701：输入相似函数对集合FF＝{ff_i|i＝0,1,…,n}；n为FF中函数对的个数；

步骤S702：将FF＝{ff_i|i＝0,1,…,n}中的第一个函数对ff₀作为第一个子图加入子图集，初始化相似子图集G＝{{ff₀}}和计数器i＝1；

步骤S703：遍历子图集G＝{G_j|j＝0,1,…,m}，初始化计数器j＝1；m为子图集G中的子图个数；

步骤S704：判断ff_i是否与G_j冲突，若是，则转入步骤S707，否则转入步骤S705；

步骤S705：基于函数调用图，判断对于ff_i，是否存在G_j中的函数对与其符合调用关系，若是，则转入步骤S706，否则转入步骤S707；

步骤S706：将ff_i加入图G_j组成的子图加入子图集G中，G＝G∪{G_j∪{ff_i}}；

步骤S707：判断是否计数器j＝＝m，若是，则转入步骤S709，否则转入步骤S708；

步骤S708：计数器j++，并转入步骤S704进行下一轮的分析；

步骤S709：将函数对ff_i作为一个子图加入子图集G中，G＝G∪{{ff_i}}；

步骤S710：判断是否计数器i＝＝n，若是，则转入步骤S712，否则转入步骤S711；

步骤S711：计数器i++，并转入步骤S703进行下一轮的分析；

步骤S712：输出当前相似子图集G。

本发明的进一步改进在于：步骤S104中判断一个函数对ff_i＝(Fun_i,Fun_i')是否与子图G_j冲突的方法是：如果存在ff＝(Fun,Fun')∈G_j，使得Fun_i＝Fun且Fun_i'≠Fun'，或Fun_i'＝Fun'且Fun_i≠Fun，则函数对ff_i与子图G_j冲突。

相对于现有技术，本发明具有以下有益效果：

1)本发明方法能够直接针对二进制代码，不依赖于源代码，不依赖特定的编程语言或平台，具有更好的适用性；

2)本发明的检测手段可以应对各种各样的成熟、强力的代码混淆技术和工具，提高对深度混淆的检测能力；

3)本发明方法不仅能够应用于整体抄袭的情况，还能够应对局部抄袭的场景；

4)不同于现有的抄袭检测技术，本方法不仅可以提供是否存在抄袭的结果，并且对抄袭情况，可以提供具体且有力的抄袭证据。

附图说明

图1为本发明基于最小分支路径函数胎记的软件局部抄袭证据生成方法整体流程图；

图2为基于最小分支路径的函数胎记提取过程流程图；

图3为基本块的最小分支路径提取过程流程图；

图4为函数间相似度计算方法流程图；

图5为路径间相似度计算方法流程图；

图6为最优相似子图集发现方法流程图；

图7为相似子图集生成过程流程图；

图8为函数的控制流图及其最小分支路径的示意图；其中图8(a)为函数F的控制流图；图8(b)为函数F的所有最小分支路径图；

图9为程序的函数调用图及最优相似子图的示意图；其中图9(a)为程序P函数调用图示意图；图9(b)为程序Q函数调用图示意图；图9(c)为程序P、Q最优相似子图示意图。

具体实施方式

以下结合附图详细说明本发明基于最小分支路径函数胎记的软件局部抄袭证据生成方法的具体实施方式。

图1为基于最小分支路径函数胎记的软件局部抄袭证据生成方法整体处理流程。

本发明一种基于最小分支路径函数胎记的软件局部抄袭证据生成方法，包括以下步骤：

步骤S101：使用逆向分析工具如IDA pro、Binnavi等，实现对原告程序P及被告程序Q对应的可执行二进制代码的反汇编，提取出其包含的静态信息，进行预处理并以数据表的形式存储。

具体而言，提取并分析与基本块，函数，指令，助记符，操作数，函数内静态控制流图以及函数间调用图的有关的静态信息，删除库函数以及指令数小于3的函数，得到有效的函数信息，并对其进行整理与分析，按照下表所示，以数据表的形式记录存储所有数据。

表1:数据表表名及结构

表名	表结构
		Functions	address#name#type
BasicBlocks	id#parent_function#adress
		BasicBlocks_Instructions	basicblock_id#instruction_address
Instructions	address#mnemonic
		Operands	address#expression_tree_id
Expression_Tree_Nodes	expression_tree_id#expression_node_id
		Expression_Nodes	id#type#symbol#immediate#parent_id
Control_Flow_Graphs	id#parent_function#source#destination
		Callgraph	id#source#destination

步骤S102：基于程序的函数内静态控制流图构建函数胎记，一个函数F_id的函数胎记FB_id是其所有最小分支路径构成的集合PATH＝{path_id,i|i＝0,1,…n}，提取原告程序P与被告程序Q内所有函数对应的函数胎记PB＝{FB_i|i＝0,1,…,m₁}以及QB＝{FB_j'|j＝0,1,…,m₂}；n为函数胎记FB_id的所有最小分支路径的个数，m₁和m₂分别为原告程序P与被告程序Q中所有函数胎记的个数。

结合图2，具体而言，将一个分支的起始基本块到下一个分支的起始基本块之间的基本块所包含的指令序列作为函数的一条最小分支路径，基于最小分支路径的函数胎记提取具体包括以下步骤：

步骤S201：初始化最小分支路径的集合以及计数器id＝0；

步骤S202：从函数内静态控制流图中读取基本块b_id的内容；

步骤S203：判断是否计数器id＝＝0或b_id的分支数目大于等于2，若是，则转入步骤S204，否则转入步骤S206；

步骤S204：提取以基本块b_id为起点的所有最小分支路径集合PATH_id＝{path_id,i|i＝0,1,…,m}，并将该集合加入所属函数胎记集合，PATH＝PATH∪PATH_id；m为以基本块b_id为起点的所有最小分支路径的个数；

步骤S205：判断是否计数器id＝＝n，若是，则转入步骤S207，否则转入步骤S206；

步骤S206：计数器id++，并转入步骤S202进行下一轮的分析；

步骤S207：输出最小分支路径的集合PATH作为函数F的函数胎记FB。

其中，提取基本块b_id的最小分支路径的方法具体包括以下步骤：

步骤S301：输入基本块b_id及其m+1个后继基本块b_id,0,b_id,1,...b_id,m；

步骤S302：初始化b_id的最小分支路径的集合以及计数器i＝0；

步骤S303：为其后继基本块b_id,i创建一条以b_id为起点的路径path_id,i，path_id,i＝b_id+b_id,i；

步骤S304：创建指针pt指向当前后继基本块b_id,i，pt→b_id,i；

步骤S305：判断指针pt指向的基本块是否有且只有一个后继基本块pt.b_s，若是，则转入步骤S306，否则转入步骤S307；

步骤S306：将后继基本块pt.b_s加入路径path_id,i中，path_id,i＝path_id,i+pt.b_s，指针pt指向其后继基本块pt.b_s，pt→pt.b_s，并转入步骤S305进行下一轮的分析；

步骤S307：将当前路径path_id,i并入b_id的最小分支路径的集合PATH_id来，PATH_id＝PATH_id∪{path_id,i}，计数器i++；

步骤S308：判断是否计数器i>m，若是，则转入步骤S309，否则转入步骤S303进行下一轮的分析；

步骤S309：输出基本块b_id的所有最小分支路径集合PATH_id。

例如函数F的控制流图如图8(a)所示，则按照以上步骤可提取出最小分支路径4条如图8(b)所示，构成该函数的函数胎记。

步骤S103：基于原告程序P内的所有函数胎记，计算其对于被告程序Q内的所有函数的函数胎记相似度SIM(FB_i,FB_j'),FB_i∈PB&&FB_j'∈QB。其中函数胎记之间相似度的计算方法是：令函数Fun_1的胎记FB₁与函数Fun_2的胎记FB₂分别表示为PATH₁＝{path_1,i|i＝0,1,…,a}，PATH₂＝{path_2,j|j＝0,1,…,b}，a为函数Fun_1的函数胎记的所有最小分支路径的个数；b为函数Fun_2的函数胎记的所有最小分支路径的个数；对于PATH₁中的每一条路径path_1,i，计算其与PATH₂中每一条路径path_2,j的相似度，基于这些相似度，寻找与path_1,i最匹配的路径path_2,match，并记录其相似度sim(path_1,i,path_2,match)。基于Fun_1的静态信息，以路径中包含的汇编指令个数l_i为权值，进行加权计算，从而得到函数胎记FB₁与函数胎记FB₂之间的相似度SIM(FB_i,FB_j')。

具体包括以下步骤：

步骤S401：初始化计数器i＝0；

步骤S402：从函数Fun_1的函数胎记PATH₁＝{path_1,i|i＝0,1,…,a}中读取最小分支路径path_1,i；

步骤S403：读取函数Fun_2的函数胎记PATH₂＝{path_2,j|j＝0,1,…,b}，计算path_1,i与PATH₂中每一条路径path_2,j的相似度；

步骤S404：寻找与path_1,i最匹配的路径path_2,match，并记录其相似度sim(path_1,i,path_2,match)，存入路径间相似度矩阵SIM_Path中，SIM_Path＝[sim(path_1,i,path_2,match)],i＝0,1,…,a；

步骤S405：判断是否计数器i＝＝a，若是，则转入步骤S407，否则转入步骤S406；

步骤S406：计数器i++，并转入步骤S402进行下一轮的分析；

步骤S407：基于路径间相似度矩阵SIM_Path以及从函数胎记PATH₁中读取的Fun_1的静态信息，以路径中包含的汇编指令个数l_i为权值，进行加权计算，计算公式为：

式中：

l_i——函数Fun_1中第i条最小分支路径包含的汇编指令的个数；

步骤S408：输出函数Fun_1与函数Fun_2之间的相似度SIM(Fun_1,Fun_2)＝SIM(FB₁,FB₂')，并存入函数间相似度矩阵SIM_Fun中，SIM_Fun＝[SIM(Fun_i,Fun_j)],i＝0,1,…,m₁,j＝0,1,…,m₂。

例如函数Fun_1包含路径path1、path2、path3，函数Fun_2包含路径pathA、pathB、pathC，它们两两之间的相似度如下表所示，则路径间相似度矩阵SIM_Path＝[0.990.870.86]。

表2：路径相似度举例示意图

相似度	pathA	pathB	pathC
				path1	0.76	0.86	0.99
path2	0.54	0.87	0.18
				path3	0.86	0.15	0.47

如果路径path1、path2、path3中包含的汇编指令个数分别为19、25、8，则函数Fun_1与函数Fun_2之间的相似度

其中路径path_1,i与path_2,j之间相似度的计算方法可分为四个步骤，分别是预处理，校准路径，基于助记符和操作数关联的汇编指令相似值计算，以及路径相似度计算。具体包括以下步骤：

步骤S501：输入最小分支路径path_1,i与path_2,j；

步骤S502：对路径path_1,i和path_2,j进行预处理，首先删除路径中所包含的跳转指令(包括JE、JNE、JZ、JNZ、JS、JNS、JC、JNC、JO、JNO、JA、JNA、JAE、JNAE、JG、JNG、JGE、JNGE、JB、JNB、JBE、JNBE、JL、JNL、JLE、JNLE、JP、JNP、JPE、JPO等跳转指令)；接着抽象化操作数，将构成路径的指令中的具体操作数抽象为三类：寄存器，存储单元以及变量名，分别用REG，MEM，VAL来表示；

步骤S503：使用LCS算法校准路径，以相同的助记符作为基准，对要进行相似性计算的两条路径path_1,i,path_2,j进行校准。校准后的两条路径为path_1,i',path_2,j'，这两条路径汇编指令的数目是相同的，同时对应位置上的汇编指令的助记符也是相同的；

步骤S504：基于助记符和操作数关联的汇编指令相似值计算，令校准后的路径path_1,i',path_2,j'表示为path_1,i'＝<ins₁,ins₂,…,ins_n>,path_2,j'＝<ins₁',ins₂',…,ins_n'>,其中，n为每条路径的汇编指令的数目。计算path_1,i',path_2,j'之间的相似值，首先计算对应位置的汇编指令ins_pos,ins_pos'之间的相似值，计算方法为取对应位置的相同操作数的个数，令ins_pos,ins_pos'表示两条汇编指令，args(ins_pos)[i]表示汇编指令ins_pos的第i个操作数，计算公式为：

sim_ins(ins_pos,ins_pos')＝|{i|args(ins_pos)[i]＝args(ins_pos')[i]}|

式中：

ins_pos,ins_pos'——两条汇编指令；

args(ins_pos)[i]——汇编指令ins_pos的第i个操作数；

步骤S505：进行路径相似度计算，将path_1,i'中汇编指令的相似值相加，得到path_1,i',path_2,j'之间的相似值score(path_1,i',path_2,j')，计算公式为采用相同的方法，得到path_1,i，path_2,j与其自身的相似值score(path_1,i,path_1,i)与score(path_2,j,path_2,j)。最后，进行标准化，得到路径path_1,i，path_2,j之间的相似度

步骤S506：输出最小分支路径path_1,i与path_2,j间的相似度sim(path_1,i,path_2,j)。

例如路径path1＝<(push,ebp),(mov,ebp,esp),(push,ebx),(sub,esp,4h),(cmp,byte ds:[completed.6159],byte 0h),(jnz,loc_8049F6F),(mov,byte ds:[completed.6159],byte 1h)>，path2＝(mov,eax,ds:[dtor_idx.6161]),(mov,ebx,__DTOR_END__),(sub,ebx,__DTOR_LIST__),(sar,ebx,byte 2h),(sub,ebx,1h),(cmp,eax,ebx),(jnb,loc_8049F68),(lea,esi,ds:[esi+0h])>，经过预处理可抽象为path1＝<(push,REG),(mov,REG,REG),(push,REG),(sub,REG,VAL),(cmp,MEM,VAL),(mov,MEM,VAL)>，path2＝(mov,REG,MEM),(mov,REG,VAL),(sub,REG,VAL),(sar,REG,VAL),(sub,REG,VAL),(cmp,REG,REG),(lea,REG,MEM)>，采用LCS算法，以相同的助记符作为基准，校准后的两条路径为path1’＝<(mov,REG,REG),(sub,REG,VAL),(cmp,MEM,VAL)>，path2’＝(mov,REG,MEM),(sub,REG,VAL),(cmp,REG,REG)>，两条路径对应的指令之间的相似值依次为1、2、0，则校准后路径的相似值为score(path1',path2')＝3，最后通过标准化得到路径间的相似值为

步骤S104：基于函数间的相似度以及函数间调用图，发现相似子图集，构建最优相似子图集。首先基于给定的阈值以及函数间的相似度，进行相似函数对的筛选；生成所有相似函数对的的相似子图集，然后从中提取最优相似子图，构建最优相似子图集。

具体描述为：相似子图G₁→G₁'是指以函数为节点，函数的调用关系为边，对应节点相似度较高且对相似的函数有相同的调用关系的子图。最优相似子图是指，对每个子图基于节点数目、对应节点相似值和节点权重赋予一个分数，分数最高的子图为该子图的最优相似子图。最优相似子图集是指每次加入一个最优相似子图所得到的集合{G₁→G₁',G₂→G₂',...,G_n→G_n'}，G₁,G₂,...G_n属于原告程序P，G₁',G₂',...G_n'属于被告程序Q，且G₁,G₂,...G_n不相交，G₁',G₂',...G_n'不相交。

最优相似子图集发现的方法具体包括以下步骤：

步骤S601：输入阈值ε₁和ε₂，ε₁用于筛选相似函数对，ε₂用于判断是否可以结束循环；其中阈值ε₁的取值为0.5～1；ε₂的取值大于1小于第一个提取的最优相似子图G_b的分数S_b；

步骤S602：基于函数间相似度矩阵SIM_Fun，筛选出相似度大于一定阈值ε₁的相似函数对FF：

FF＝{(Fun_i,Fun_j)|Fun_i∈P&&Fun_j∈Q&&SIM(Fun_i,Fun_j)>ε₁}；

步骤S603：基于函数间调用图，生成FF的相似子图集G，并计算子图分数S；

子图分数S是指子图中所有函数对的相似度的和，计算公式为：

式中，n为子图中所有函数对的数目；

步骤S604：提取最优相似子图G_b，记录其分数S_b，将其并入最优相似子图集；

步骤S605：判断是否当前最优相似子图集的分数S_b>ε₂，若是，则转入步骤S606，否则转入步骤S607；

步骤S606：更新FF，将目前最优相似子图集中包含的函数对从FF中移除，FF＝FF-{(Fun_i,Fun_j)|Fun_i∈G_b||Fun_j∈G_b}，并跳转至步骤S603进行下一轮的分析；

步骤S607：输出当前的最优相似子图集。

其中生成FF的相似子图集G的方法具体包括以下步骤：

步骤S701：输入相似函数对集合FF＝{ff_i|i＝0,1,…,n}；n为FF中函数对的个数；

步骤S702：将FF＝{ff_i|i＝0,1,…,n}中的第一个函数对ff₀作为第一个子图加入子图集，初始化相似子图集G＝{{ff₀}}和计数器i＝1；

步骤S703：遍历子图集G＝{G_j|j＝0,1,…,m}，初始化计数器j＝1；m为子图集G中的子图个数；

步骤S704：判断ff_i是否与G_j冲突(判断方法是：如果存在ff＝(Fun,Fun')∈G_j，使得Fun_i＝Fun且Fun_i'≠Fun'，或Fun_i'＝Fun'且Fun_i≠Fun，则函数对ff_i与子图G_j冲突)，若是，则转入步骤S707，否则转入步骤S705；

步骤S705：基于函数调用图，判断对于ff_i，是否存在G_j中的函数对与其符合调用关系，若是，则转入步骤S706，否则转入步骤S707；

步骤S706：将ff_i加入图G_j组成的子图加入子图集G中，G＝G∪{G_j∪{ff_i}}；

步骤S707：判断是否计数器j＝＝m，若是，则转入步骤S709，否则转入步骤S708；

步骤S708：计数器j++，并转入步骤S704进行下一轮的分析；

步骤S709：将函数对ff_i作为一个子图加入子图集G中，G＝G∪{{ff_i}}；

步骤S710：判断是否计数器i＝＝n，若是，则转入步骤S712，否则转入步骤S711；

步骤S711：计数器i++，并转入步骤S703进行下一轮的分析；

步骤S712：输出当前相似子图集G。

例如原告程序P与被告程序Q的函数调用图如图9(a)、(b)所示，其中节点代表函数，有向连接线表示的是函数之间的调用关系，通过最优相似子图的提取可得到如图9(c)所示的最优相似子图，左边的函数均属于原告程序P，右边的属于被告程序Q，虚线连接的两个函数就是相似函数对。

步骤S105：基于最优相似子图集，进行抄袭判定，如存在抄袭，生成抄袭证据。

具体描述为：

根据最优相似子图集的规模大小，并与原程序规模作比较从而判断程序是否存在抄袭，而生成的最优相似子图集则可作为被告程序Q抄袭原告程序P的抄袭证据。在实际的应用中，还需要考虑最优相似子图集中所包含的模块是否是功能模块亦或是通用模块等具体问题，如果最优相似子图集中全部为通用模块，则判断不存在抄袭；如果最优相似子图集中存在至少一个功能模块相同，则可以认定存在抄袭；如果存在抄袭，将步骤S104获得的最优相似子图集输出作为抄袭证据。其中，功能模块为原告程序所原创的模块。

Claims (10)

1.基于最小分支路径函数胎记的软件局部抄袭证据生成方法，其特征在于，包括如下步骤：

步骤S101：基于反汇编技术，对原告程序P及被告程序Q对应的可执行二进制文件进行反汇编，记录并分析生成的汇编代码，对于其包含的静态信息进行预处理并以数据表的形式存储；

步骤S102：基于程序的函数内静态控制流图，将一个分支的起始基本块到下一个分支的起始基本块之间的基本块所包含的指令序列作为函数的一条最小分支路径，一个函数F_id的函数胎记FB_id是其所有最小分支路径构成的集合PATH＝{path_id,i|i＝0,1,…n}，提取原告程序P与被告程序Q内所有函数对应的函数胎记PB＝{FB_i|i＝0,1,…,m₁}以及QB＝{FB_j'|j＝0,1,…,m₂}；n为函数胎记FB_id的所有最小分支路径的个数，m₁和m₂分别为原告程序P与被告程序Q中所有函数胎记的个数；

步骤S103：基于原告程序P内的所有函数胎记，计算其对于被告程序Q内的所有函数的函数胎记相似度SIM(FB_i,FB_j'),FB_i∈PB&&FB_j'∈QB；

步骤S104：基于函数间的相似度以及函数间调用图，发现相似子图集，构建最优相似子图集；

步骤S105：基于最优相似子图集，进行抄袭判定，如存在抄袭，生成抄袭证据。

2.根据权利要求1所述的方法，其特征在于，所述步骤S101具体为使用逆向分析工具来撤除编译和汇编过程，输入为机器语言，输出结果为汇编语言；对原告及被告程序P，Q对应的二进制可执行文件进行反汇编，对反汇编后输出的汇编代码进行分析，对程序包含的静态信息进行预处理，删除库函数以及过小的函数，得到有效的函数信息，以数据表的形式记录存储；

所述静态信息具体包括：基本块，函数，指令，助记符，操作数，函数内静态控制流图以及函数间调用图；

所述过小的函数为指令数小于3的函数。

3.根据权利要求1所述的方法，其特征在于，步骤S102中基于最小分支路径的函数胎记FB_id即最小分支路径集合PATH的提取方法是基于函数的静态控制流图，对函数内的每一个基本块b_id进行分析，如果该基本块的分支大于等于2或该基本块为所属函数的起始基本块，则提取以该基本块为起点的所有最小分支路径集合PATH_id＝{path_id,i|i＝0,1,…,m},并将该集合加入所属函数胎记集合，PATH＝PATH∪PATH_id，m为以基本块b_id为起点的所有最小分支路径的个数。

4.根据权利要求3所述的方法，其特征在于，步骤S102中提取基本块b_id的最小分支路径的方法是为其每一个分支创建一条以b_id为起点的路径path_id,i，对于每一条路径，将其后继基本块不断加入该路径中，直至遇到下一个分支，则该路径经过的基本块内的汇编指令构成了该最小分支路径，这些路径的集合PATH_id即为以该基本块为起点的所有最小分支路径。

5.根据权利要求4所述的方法，其特征在于，步骤S102中提取基本块中汇编指令的方法是：首先读取汇编指令的助记符，接着读取该汇编指令对应的操作数的表达树id，根据表达树id读取对应的节点id，从而读取节点id对应的符号或立即数，遍历该表达树的各个节点，得到操作数，最后将助记符与操作数组合，得到该汇编指令的表达形式。

6.根据权利要求1所述的方法，其特征在于，步骤S103中函数胎记之间相似度的计算方法是：令原告程序P中的函数Fun_1的胎记FB₁与被告程序Q中函数Fun_2的胎记FB₂'分别表示为PATH₁＝{path_1,i|i＝0,1,…,a}，PATH₂＝{path_2,j|j＝0,1,…,b}，对于PATH₁中的每一条路径path_1,i，计算其与PATH₂中每一条路径path_2,j的相似度，基于这些相似度，寻找与path_1,i最匹配的路径path_2,match，并记录其相似度sim(path_1,i,path_2,match)；基于Fun_1的静态信息，以路径中包含的汇编指令个数l_i为权值，进行加权计算，从而得到函数胎记FB₁与函数胎记FB₂的相似度，计算公式为：

<mrow> <mi>S</mi> <mi>I</mi> <mi>M</mi> <mrow> <mo>(</mo> <msub> <mi>FB</mi> <mn>1</mn> </msub> <mo>,</mo> <msup> <msub> <mi>FB</mi> <mn>2</mn> </msub> <mo>&amp;prime;</mo> </msup> <mo>)</mo> </mrow> <mo>=</mo> <munderover> <mo>&amp;Sigma;</mo> <mrow> <mi>i</mi> <mo>&lt;</mo> <mi>o</mi> </mrow> <mrow> <mi>i</mi> <mo>=</mo> <mn>0</mn> </mrow> </munderover> <mrow> <mo>(</mo> <mfrac> <msub> <mi>l</mi> <mi>i</mi> </msub> <mrow> <munderover> <mo>&amp;Sigma;</mo> <mrow> <mi>i</mi> <mo>&lt;</mo> <mi>o</mi> </mrow> <mrow> <mi>i</mi> <mo>=</mo> <mn>0</mn> </mrow> </munderover> <msub> <mi>l</mi> <mi>i</mi> </msub> </mrow> </mfrac> <mo>&amp;times;</mo> <mi>s</mi> <mi>i</mi> <mi>m</mi> <mo>(</mo> <mrow> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>m</mi> <mi>a</mi> <mi>t</mi> <mi>c</mi> <mi>h</mi> </mrow> </msub> </mrow> <mo>)</mo> <mo>)</mo> </mrow> </mrow>

式中：

l_i——函数Fun_1中第i条最小分支路径包含的汇编指令的个数；

所述a为函数Fun_1的函数胎记的所有最小分支路径的个数；b为函数Fun_2的函数胎记的所有最小分支路径的个数；

则函数之间的相似度SIM(Fun_1,Fun_2)＝SIM(FB₁,FB₂')。

7.根据权利要求6所述的方法，其特征在于，步骤S103中路径path_1,i与path_2,j之间相似度的计算方法分为四个步骤，分别是预处理，校准路径，基于助记符和操作数关联的汇编指令相似值计算，以及路径相似度计算；具体如下：

a)预处理：预处理的方法是首先删除路径中所包含的跳转指令，接着将操作数抽象化；操作数抽象化是指将构成路径的指令中的具体操作数抽象为三类：寄存器，存储单元以及变量名，分别用REG，MEM，VAL来表示；

b)校准路径：校准路径的方法是使用LCS算法，以相同的助记符作为基准，对要进行相似性计算的两条路径path_1,i,path_2,j进行校准；校准后的两条路径为path_1,i',path_2,j'，这两条路径汇编指令的数目是相同的，同时对应位置上的汇编指令的助记符也是相同的；

c)基于助记符和操作数关联的汇编指令相似值计算：令校准后的路径path_1,i',path_2,j'表示为path_1,i'＝<ins₁,ins₂,…,ins_n>,path_2,j'＝<ins₁',ins₂',…,ins_n'>,其中，n为每条路径的汇编指令的数目；计算path_1,i',path_2,j'之间的相似值，首先计算对应位置的汇编指令ins_pos,ins_pos'之间的相似值，计算方法为对应位置的相同操作数的个数：

sim_ins(ins_pos,ins_pos')＝|{i|args(ins_pos)[i]＝args(ins_pos')[i]}|

式中：ins_pos,ins_pos'——两条汇编指令；

args(ins_pos)[i]——汇编指令ins_pos的第i个操作数；

d)路径相似度计算：将path_1,i'中汇编指令的相似值相加，得到path_1,i',path_2,j'之间的相似值score(path_1,i',path_2,j')；采用相同的方法，得到path_1,i，path_2,j与其自身的相似值score(path_1,i,path_1,i)与score(path_2,j,path_2,j)；最后，进行标准化，得到路径path_1,i，path_2,j之间的相似度；

<mrow> <mi>s</mi> <mi>c</mi> <mi>o</mi> <mi>r</mi> <mi>e</mi> <mrow> <mo>(</mo> <msup> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>&amp;prime;</mo> </msup> <mo>,</mo> <msup> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>j</mi> </mrow> </msub> <mo>&amp;prime;</mo> </msup> <mo>)</mo> </mrow> <mo>=</mo> <munderover> <mo>&amp;Sigma;</mo> <mrow> <mi>p</mi> <mi>o</mi> <mi>s</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>n</mi> </munderover> <mi>s</mi> <mi>i</mi> <mi>m</mi> <mo>_</mo> <mi>i</mi> <mi>n</mi> <mi>s</mi> <mrow> <mo>(</mo> <msub> <mi>ins</mi> <mrow> <mi>p</mi> <mi>o</mi> <mi>s</mi> </mrow> </msub> <mo>,</mo> <msup> <msub> <mi>ins</mi> <mrow> <mi>p</mi> <mi>o</mi> <mi>s</mi> </mrow> </msub> <mo>&amp;prime;</mo> </msup> <mo>)</mo> </mrow> </mrow>

<mrow> <mi>s</mi> <mi>i</mi> <mi>m</mi> <mrow> <mo>(</mo> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>j</mi> </mrow> </msub> <mo>)</mo> </mrow> <mo>=</mo> <mfrac> <mrow> <mi>s</mi> <mi>c</mi> <mi>o</mi> <mi>r</mi> <mi>e</mi> <mrow> <mo>(</mo> <msup> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>&amp;prime;</mo> </msup> <mo>,</mo> <msup> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>j</mi> </mrow> </msub> <mo>&amp;prime;</mo> </msup> <mo>)</mo> </mrow> <mo>&amp;times;</mo> <mn>2</mn> </mrow> <mrow> <mi>s</mi> <mi>c</mi> <mi>o</mi> <mi>r</mi> <mi>e</mi> <mrow> <mo>(</mo> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>path</mi> <mrow> <mn>1</mn> <mo>,</mo> <mi>i</mi> </mrow> </msub> <mo>)</mo> </mrow> <mo>+</mo> <mi>s</mi> <mi>c</mi> <mi>o</mi> <mi>r</mi> <mi>e</mi> <mrow> <mo>(</mo> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>j</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>path</mi> <mrow> <mn>2</mn> <mo>,</mo> <mi>j</mi> </mrow> </msub> <mo>)</mo> </mrow> </mrow> </mfrac> <mo>.</mo> </mrow>

8.根据权利要求1所述的方法，其特征在于，步骤S104中，相似子图是指以函数为节点，函数的调用关系为边，对应节点相似度较高且对相似的函数有相同的调用关系的子图；最优相似子图是指，对每个子图基于节点数目、对应节点相似值和节点权重赋予一个分数，分数最高的子图为该子图的最优相似子图；最优相似子图集是指每次加入一个最优相似子图所得到的集合{G₁→G₁',G₂→G₂',...,G_n→G_n'}，G₁,G₂,...G_n属于原告程序P，G₁',G₂',...G_n'属于被告程序Q，且G₁,G₂,...G_n不相交，G₁',G₂',...G_n'不相交；G_i→G_i'为一个相似子图，其中i＝1，2，…n。

9.根据权利要求8所述的方法，其特征在于，步骤S104中最优相似子图集发现的方法是：

1)筛选出相似度大于阈值ε₁的相似函数对：

FF＝{(Fun_i,Fun_j)|Fun_i∈P&&Fun_j∈Q&&SIM(Fun_i,Fun_j)>ε₁}；

2)基于函数间调用图，生成FF的相似子图集G，并计算每个子图的分数S；

子图分数S是指子图中所有函数对的相似度的和，计算公式为：

式中，n为子图中所有函数对的数目；

3)提取最优相似子图G_b，记录其分数S_b，并入最优相似子图集；

4)如果最优相似子图的分数大于ε₂，更新FF，将目前最优相似子图集中包含的函数对从FF中移除，FF＝FF-{(Fun_i,Fun_j)|Fun_i∈G_b||Fun_j∈G_b}，并跳转至步骤2)；否则，结束，并输出当前的最优相似子图集；

其中阈值ε₁的取值为0.5～1；ε₂的取值大于1小于第一个提取的最优相似子图G_b的分数S_b。

10.根据权利要求9所述的方法，其特征在于，步骤S104中生成FF的相似子图集G的方法是：

2.1)将FF＝{ff_i|i＝0,1,…,n}中的第一个函数对ff₀作为一个子图加入子图集G中；G＝{{ff₀}}；n为FF中函数对的个数；

2.2)从ff_i，i＝1开始，遍历FF，对于ff_i：

a)遍历子图集G＝{G_j|j＝0,1,…,m}；m为子图集G中的子图个数；

b)如果ff_i与G_j不冲突，且基于函数调用图，对于ff_i，存在G_j中的函数对与其符合调用关系，则G＝G∪{G_j∪{ff_i}}；

2.3)将函数对ff_i作为一个子图加入子图集G中，G＝G∪{{ff_i}}；

2.4)输出相似子图集G；

步骤S104中判断一个函数对ff_i＝(Fun_i,Fun_i')是否与子图G_j冲突的方法是：如果存在ff＝(Fun,Fun')∈G_j，使得Fun_i＝Fun且Fun_i'≠Fun'，或Fun_i'＝Fun'且Fun_i≠Fun，则函数对ff_i与子图G_j冲突。