CN104200139B - The generation method of instruction code in a kind of Java software watermark void method - Google Patents

Abstract

The invention relates to a method for generating instruction codes in a Java software watermark virtual method, based on a BCEL class library, comprising the following steps: 1) loading a Java class file to be embedded with an instruction through the BCEL class library, and parsing the class file, Convert into a Java class file object that meets the BCEL processing requirements; 2) Obtain the parameter information of the class file from the Java class file object, the parameter information includes the method in the class, and then find and take out the virtual method from the obtained method ;3) Create a new virtual method based on the obtained virtual method and parameter information to replace the original virtual method; 4) Generate instruction codes for embedding watermark information, and add them to the instruction set of the new virtual method Middle; 5) Put the new virtual method into the Java class file. Beneficial effects are: the invention can automatically generate instruction codes for embedding watermark information in the virtual method through computer programs, which solves the problems of needing to be manually written by professionals in the past, lacking versatility, and inconvenient for practical application.

Description

A Method of Instruction Code Generation in Java Software Watermark Virtual Method

technical field

The invention relates to a software watermark, in particular to a method for generating instruction codes in a Java software watermark virtual method.

Background technique

The software industry has developed rapidly in recent years and has become a major industry with an annual output value of hundreds of billions. At the same time, the problem of illegal duplication and misappropriation of software products has also become very serious and has attracted widespread attention from both inside and outside the industry. Software watermarking is a technology that has emerged in recent years to protect the intellectual property rights of software products. It embeds copyright protection information or identity authentication information (ie watermark) in software works without affecting software functions. When the program is illegally copied or In case of misappropriation, this information can be extracted to prove the ownership of the software work.

At present, the Java language is widely used, and the software developed with the Java language occupies a large proportion. The Java language has cross-platform portability and is easy to use, but it also brings the problem that the program is easy to be copied and stolen. Research and development of software watermark technology for copyright protection of Java language programs has very important practical significance and application value. Among the existing Java software watermarking techniques, the software watermarking algorithm based on virtual method and class file bytecode first proposed by Akito Monden et al. has good practicability and realizability, and can be used to protect Java class files. The basic idea of the algorithm is to implant a method that will never be executed in the Java program that needs to be protected, which is called a virtual method. Since the virtual method will not actually be executed, we can write the program code in the virtual method as needed. Then, in the bytecode corresponding to the virtual method, modify the operand of the instruction or encode the operation code of the instruction to embed the watermark information.

For the above algorithm proposed by Akito Monden et al., the focus and achievement of the existing research is how to embed and extract watermark information by modifying the operand and encoding the operation code in the instruction code of the virtual method. How the program code in virtual methods is generated has not been well studied. Generally, according to the embedded watermark information, it needs to be written manually by professionals, which is not universal and inconvenient, so that the practical application of the algorithm is limited. The invention proposes a method and technology for automatically generating instruction codes for embedding watermark information in virtual methods through computer programs. Based on the present invention, as long as the user provides the watermark information to be embedded, the system will automatically generate the corresponding instruction code in the virtual method without manual intervention. In this way, a convenient and practical Java software watermarking application system can be designed and developed.

Contents of the invention

The purpose of the present invention is to overcome the above-mentioned deficiencies in the prior art, and provide a method for automatically generating instruction codes in a Java software watermark virtual method. This method uses the BCEL class library provided by Apache Web service software for manipulating Java class files to operate on given Java class files. Specifically, the following technical solutions are implemented:

The generation method of instruction code in the described Java software watermark virtual method, based on BCEL class storehouse, specifically comprises the steps:

1) Load the Java class file of the instruction to be embedded through the BCEL class library, analyze the class file, and convert it into a Java class file object meeting the BCEL processing requirements;

2) obtain the parameter information of class file from described Java class file object, described parameter information comprises the method in the class, then finds and takes out virtual method from the method obtained;

3) Create a new virtual method based on the obtained virtual method and parameter information to replace the original virtual method;

4) generate instruction codes for embedding watermark information, and add them to the instruction set of the new virtual method;

5) Put the new virtual method into the Java class file.

A further design of the instruction code generation method in the Java software watermark virtual method is that the parameter information also includes the class file name and constant pool of the Java class file.

The further design of the generation method of the instruction code in the virtual method of the Java software watermark is that the generation of the instruction code used to embed the watermark information includes:

Modifying the operands, configuring the operands to embed the watermark information by modifying the operands, combining them into a complete instruction, adding the instruction code to the instruction set of the new virtual method in the class;

Encode the operation code, generate the operation code code book, select the corresponding operation code according to the code to be embedded, configure the operand, combine into a complete instruction, and add the instruction code to the instruction set of the new virtual method in the class.

The further design of the method for generating instruction codes in the Java software watermark virtual method is that the process of modifying the operands can implement a number of instructions corresponding to the size of the embedded watermark information through a loop statement according to the size of the embedded watermark information.

The further design of the generation method of instruction code in the virtual method of the Java software watermark is that the process of modifying the operand specifically includes the following steps:

A) Utilize a random function to generate the required operands for the instruction to embed the watermark information;

B) Combining the operation code and the operand into an instruction and storing it in a temporary collection;

C) Copy the instructions in the temporary set to the instruction set of the new virtual method in the class.

The further design of the generation method of instruction code in described Java software watermark virtual method is that, the process of described encoding operation code specifically comprises the following steps:

1) generate a codebook by mapping, each encoding in the codebook forms a one-to-one mapping relationship with an instruction opcode;

Ⅱ) Find the corresponding instruction opcode from the codebook according to the code to be embedded;

Ⅲ) Generate the operand of the above-mentioned instruction opcode by a random function;

Ⅳ) Combining the opcode and the operand into an instruction and storing it in a temporary collection;

V) Copy the instructions in the temporary set into the instruction set of the new virtual method.

The method for generating instruction codes in the Java software watermark virtual method proposed by the present invention can automatically generate instruction codes for embedding watermark information in the virtual method through computer programs, which solves the need for professionals to manually write in the past, which has no versatility and is inconvenient for practice. application problem. With the present invention, as long as the user provides the watermark information to be embedded, the system will automatically generate corresponding instruction codes in the virtual method without manual intervention. On this basis, a convenient and practical Java software watermark application system can be designed and developed.

Description of drawings

Fig. 1 is a functional block diagram of a method for generating instruction codes in the Java software watermark virtual method.

Figure 2 is a schematic diagram of the class files used for testing.

Fig. 3 is a schematic diagram of instructions in a virtual method.

FIG. 4 is a schematic diagram of the comparison before and after adding instructions in the virtual method.

FIG. 5 is a schematic diagram of instructions in a virtual method after adding instructions.

detailed description

The solution of the present invention will be described in detail below in conjunction with the accompanying drawings.

The generation method of instruction code in the Java software watermark virtual method provided by this embodiment, referring to Fig. 1, is as follows:

Step 1: Load the Java class file of the instruction to be embedded through the BCEL class library. Assuming that the file name of the Java class file is TestClass.class, the path is "D:\\test file\\TestClass.class", and the character string storing the absolute path of this class file is targetClassfile, then the implementation of the Java class file is loaded The code is:

String targetClassfile="D:\\test file\\TestClass.class";

Call the class file parser ClassParser of the BCEL class library to parse the loaded Java class file in order to obtain its class file name, constant pool, method and other information. The relevant implementation code is:

JavaClass jc = new ClassParser(targetClassfile). parse();

Among them, jc is the file-like object generated after parsing.

The parsed class file object jc package is transformed into an object of the ClassGen class in the BCEL class library, so as to call the method of the ClassGen class to obtain the relevant information of the class file. The relevant implementation code is:

ClassGen cg = new ClassGen(jc);

Among them, cg is the converted Java class file object, and the two objects jc and cg will be directly used below.

The second step: obtain the relevant information of the loaded Java class file, including the class file name, the constant pool and the method in the class, and find and take out the virtual method from the method.

The class file name and constant pool are obtained through the cg object. The class file name is obtained by calling the getClassName() method of the ClassGen class:

String cname = cg. getClassName();

The constant pool is obtained by calling the getConstantPool() method of the ClassGen class:

ConstantPoolGen cpg = cg.getConstantPool();

The methods in the class are obtained through the jc object, and the code to obtain all the methods in the class from the jc object is:

Method[] methods = jc.getMethods();

Find the virtual method from all methods according to the virtual method name. Assume that the virtual method name is "dummy", and the relevant implementation code is:

The virtual method is also taken out of the class through the cg object, and the removeMethod(method) method of the ClassGen class is called:

cg. removeMethod(method);

Among them, method represents the virtual method methods[index] found above, here is the method named "dummy".

Step 3: Create a new virtual method based on the class file name, constant pool and virtual method information obtained above to replace the original virtual method. This is achieved by calling the MethodGen class in the BCEL class library for processing methods:

MethodGen mg = new MethodGen(method,cname,cpg);

Among them, cname and cpg are the original class file name and constant pool, method is the original virtual method, and mg is the object of the generated MethodGen class.

Step 4: Obtain the instruction set of the newly created virtual method through the object mg of the above MethodGen class:

InstructionList lst = mg. getInstructionList();

Then add instructions for embedding watermark information to the instruction set. Instructions can be inserted into the instruction set by calling the insert() method of the MethodGen class. Take adding a "bipush" instruction as an example, the implementation code is:

lst.insert(newBIPUSH((byte)1));

The actual added instructions are related to the embedded watermark information and need to be generated by a special method, which will be described separately later. After getting these instructions, copy them to the instruction set of the above-mentioned new virtual method.

Step 5: restore the newly created virtual method containing the instruction code for embedding the watermark information to the original class, and implement it by calling the addMethod method of the ClassGen class and the getMethod method of the MethodGen class. The implementation code is:

cg. addMethod(mg. getMethod());

Among them, the getMethod method has no parameters, and the restored virtual method name is still the original name, which is dummy here.

A specific example is given below to illustrate, assuming that the test class file is named TestClass.class, as shown in Figure 2, the class contains four methods, and the method names are: func1, func2, func3 and dummy (note that <init > is a Java class file's own method, not a user-defined method). Among them, the dummy method is a virtual method. Click "[0]Code" to view the instructions in the dummy method, as shown in Figure 3.

Here we take adding a "bipush" instruction as an example to test. The program to realize the functions of the above steps is as follows, and the relevant notes are attached to the program statement.

Run the test program to complete the steps of automatic generation of instruction codes in the virtual method. Check the instructions in the virtual method in the class file again and compare them with the original instructions. It can be seen that on the basis of the original 4 instructions, a "bipush" instruction has been added. See Figure 4. The left part of the figure is the original command, the right side is after the new command. The test results are correct and the expected functions are realized.

The generation of instruction codes for embedding watermark information will be further described below. According to the bytecode-based Java software watermarking algorithm, watermark information can be embedded in two ways by modifying the operand of the instruction and encoding the opcode of the instruction.

Modification of operands: In this embodiment, there are three instructions for embedding watermark information by modifying operands: bipush, sipush, iinc, wherein iinc has 2 operands. Configure operands for these three instructions, combine them into complete instruction codes, and then add these instruction codes to the instruction set of the new virtual method in the class. The specific implementation steps are as follows:

In the first step, a random function is used to generate the required operands for these three instructions. The implementation code is:

In the second step, the operation code and the operand array are synthesized into instructions and stored in a temporary collection. The implementation code is:

The third step is to copy the instructions in the temporary collection to the instruction collection of the new virtual method in the class. The implementation code is:

for(intn=0;n<instructionList.size();n++){

lst.add(instructionList.get(n));

}

Among them, lst is a set of instructions for creating a new virtual method in the class.

Furthermore, the above code only generates three watermark-embeddable instructions in the instruction set, and in practical applications, more instructions can be generated by using loop statements according to the size of the embedded watermark information.

Encoding operation code: Use the operation code of the instruction to encode the watermark information to embed the watermark information, and the encoding includes English letters and Arabic numerals. In this embodiment, it is assumed that the watermark information is composed of lowercase English letters, 26 instructions are selected from the Java virtual machine instructions, and the 26 English letters are encoded with their operation codes. The codebook is shown in Table 1.

Table 1 Encode 26 English letters with operation code

ineg a fmul no l2i b bipush o sip push c iinc p new d d2f q if nonnull e iand r go to f d2 the s IALOAD g arraylength t ICONST h anew warray u idiv i lconst_0 v f2i j fconst_0 w newarry k isl x ior l drem the y aconst m if null z

According to the English information to be embedded, for each letter, select the corresponding operation code according to the above codebook to write instructions. The specific implementation steps are as follows:

In the first step, the codebook shown in Table 1 is generated through mapping (Map). Each code in the codebook in the table forms a one-to-one mapping relationship with an instruction operation code, so there are 26 mapping statements. In this embodiment, in order to save space, it is assumed that the watermark information to be embedded is "ntu", and only the implementation codes for encoding the three letters n, t, and u (the corresponding operation codes are fmul, arraylength, and anewarray) are given below , the other 23 Map mapping statements are similar and omitted:

Map<Character, String>HELPER=new HashMap();

HELPER. put(Character. valueOf('n'), "FMUL");

HELPER. put(Character. valueOf('t'), "ARRAYLENGTH");

HELPER. put(Character. valueOf('u'), "ANEWARRAY");

The second step is to find the corresponding instruction opcode from the above codebook according to the English letters to be embedded. The implementation code is:

In the third step, the operands of the above instructions are generated through a random function. The implementation code is:

The fourth step is to combine the operation code and the operand into an instruction, and store it in a temporary collection. Take embedding "ntu" as an example, the corresponding implementation code is:

The if statement combining the other 23 instructions is omitted in the above code, and will not be repeated here.

The fifth step is to copy the instructions in the temporary collection to the instruction collection of the new virtual method in the class. The implementation code is the same as that of modifying the operand above, and will not be repeated here.

After copying the above-mentioned generated instructions to the instruction set of the new virtual method in the class, run the program again for testing, and check the instructions in the virtual method in the class. See Figure 5, it can be seen that 3 instructions have been added on the basis of the original 4 instructions The instruction to encode "ntu", the result is correct, and achieves the expected function.

Claims (5)

1. A kind of 1. generation method of instruction code in Java software watermark void method, based on BCEL class libraries, it is characterised in that including Following steps：

   1) the java class file of instruction to be embedded, and the class file resolver for passing through BCEL class libraries are loaded into by BCEL class libraries ClassParser is parsed to the class file, and the class file object jc packagings after parsing are changed into BCEL class libraries The object of ClassGen classes；

   2) parameter information of class file is obtained from the java class file object, the parameter information includes the method in class, Found again from the method for acquisition and take out empty method, the method in the class is led to by jc object acquisitions, the acquisition of empty method The removeMethod methods for crossing ClassGen classes are realized；

   3) according to one new empty method of empty method and parameter information creating of acquisition, for substituting original empty method；The step Suddenly by calling the MethodGen classes in BCEL class libraries for processing method to realize；

   4) instruction code for being embedded in watermark information is produced, the instruction code is added to the instruction set of the new empty method In conjunction；The instruction set of the new empty method is obtained by the object mg of the MethodGen classes；Then into the instruction set Add the instruction for being embedded in watermark information；

   5) the new empty method is inserted in the java class file；

   In step 4), include for being embedded in the generation of instruction code of watermark information：

   Operand is changed, the instruction to being embedded in watermark information by changing operand, carries out configuration operand, is combined into complete Instruction, the instruction code is added in class in the instruction set of new empty method；

   Encoding operation code, generation command code coding code book, according to the coding that need to be embedded in, select corresponding command code, configuration operation Number, is combined into complete instruction, the instruction code is added in class in the instruction set of new empty method.
2. 2. the generation method of instruction code in Java software watermark void method according to claim 1, it is characterised in that institute Stating parameter information also includes the class file name and constant pool of the java class file.
3. 3. the generation method of instruction code in Java software watermark void method according to claim 1, it is characterised in that institute The process of modification operand is stated according to the size of embedded watermark information, the size with embedded watermark information is realized by Do statement The instruction of respective amount.
4. 4. the generation method of instruction code in Java software watermark void method according to claim 1, it is characterised in that institute The process for stating modification operand specifically comprises the following steps：

   A random function) is utilized to generate the operand for being embedded in needed for the instruction of watermark information；

   B command code) is synthesized into instruction with groups of operands, deposited in an interim set；

   C) instruction in the interim set is copied to described in class in the instruction set of new empty method.
5. 5. the generation method of instruction code in Java software watermark void method according to claim 3, it is characterised in that institute The process for stating encoding operation code specifically comprises the following steps：

   I) code book is generated by mapping, each coding and an instruction operation code in the code book are into mapping relations one by one；

   II) coding being embedded in as needed, finds corresponding instruction operation code from the code book；

   III) operand of above-mentioned instruction operation code is produced by random function；

   IV) command code is synthesized into instruction with groups of operands, deposited in an interim set；

   V) instruction in interim set is copied in the instruction set of the new empty method.