JP2003337629A - Program obfuscation method and device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide an obfuscation method, which obfuscate a program in a low price so as to complicate functional analysis, when the program has confidential data or confidential algorithm, and to obfuscate the program and to prevent unauthorized access to the program by means of the obfuscation method and device which are certified that the obfuscated program is difficult to be analyzed in some configurations. <P>SOLUTION: A plurality of pointer variables to function are newly installed so as not to change the specifications of the program for a source code of the program, a plurality of statements, which assigns the address of the function in one of the function pointer variables, are inserted, and the calling of the function in the program is converted so that the function is called, in response to a value of the function pointer variable. <P>COPYRIGHT: (C)2004,JPO

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention makes it difficult to analyze a program having confidential data, a confidential algorithm, etc. when it is necessary to prevent unauthorized access to the data, the algorithm, etc. The present invention relates to an obfuscation method and device for converting to.

[0002]

2. Description of the Related Art With the recent development of computer networks, the distribution of programs has changed. In the past, distribution of programs was generally done in binary format, but as seen in free software and the like, distribution of programs in source code format or formats close to that is increasing. In particular, in the mobile agent system, which has been attracting attention as a next-generation computing platform in recent years, due to the problem of model dependence, the mobile agent is realized in a source code or a form close to the source code and can move between terminals. It is commonplace.

Under such circumstances, a malicious third party may analyze a program having confidential data or a confidential algorithm, and the data may be stolen or the intellectual property right of the algorithm may be infringed. Exists. Therefore, it is considered necessary to have a method for protecting the program from such unauthorized access.

It is considered that simply encrypting the program is not sufficient as the protection method. Because the encrypted program is very difficult to analyze in the process of distribution, but the computer cannot interpret and execute it as it is, so it is necessary to decrypt the program at the time of execution. This is because it is difficult to protect the program after decryption.

Therefore, as the protection method, Japanese Patent Laid-Open No. 8-
As disclosed in Japanese Patent Publication No. 95777 “Software Usage Control Device”, a system that uses special hardware to distribute various digital contents on a network and enables charging (“super distribution”) (Known as) is proposed. Furthermore, as a method that does not use special hardware, a method has been proposed in which obfuscation makes a program have a property (tamper resistance) that is difficult to observe or tamper with from the outside. Obfuscation is referred to, for example, by Kadota, Takada, Torii, et al., "Proposal of Method for Obfuscating Program Including Loop", IEICE Transactions Vol. J80-D-INo. As described in No. 7, it is a method of converting the program so as to make the analysis difficult while keeping the specifications of the program. Especially regarding obfuscation, Wan
g, Hill, Knight, Davidson, et al., in their study "Software sampler re.
science: Obstructing station
tic analysis of programs ”
Technical Report CS-2000-
12, University of Virgini
In (a), focusing on the difficulty of analyzing pointer variables in a program, we propose an obfuscation method that can quantitatively show the difficulty of analysis of an obfuscated program. The method proposed by Wang et al. Targets only the inside of the function for obfuscation, and shows only the difficulty of the in-function analysis for the obfuscated program.

[0006]

However, in the solution method by super distribution, there is a problem that the cost increases. In addition, with regard to the obfuscation method, in many conventional methods such as Kadota's method, the difficulty of analysis of the obfuscated program is not quantitatively shown, and the effect is not clear. There is a problem. On the other hand, the obfuscation method proposed by Wang et al., Although showing the difficulty of the in-function analysis for the obfuscated program, does not target the call relationship between functions,
There is a problem that the difficulty of inter-function analysis for obfuscated programs is not shown. That is, W
The method of ang et al. is a local obfuscation method, and it is considered that the effectiveness of the method of Wang et al. is not clear when the program is viewed as a whole.

The present invention has been made to solve at least one of the above-mentioned problems, and in order to prevent unauthorized access to a program having confidential data, a confidential algorithm, etc., it is possible to use an inexpensive configuration for the program. It is an object of the present invention to provide a method and an apparatus that obfuscate the inter-function analysis so that it is difficult to analyze the obfuscated program depending on the configuration.

[0008]

An obfuscation method according to the present invention is a method for converting a source code of a program written in a programming language capable of describing functions so as not to change the specifications of the program. In this case, a plurality of pointer variables to a function are newly introduced, a plurality of statement statements for substituting the address of the function into any of the function pointer variables are inserted, and the function is called in the program by calling the function. It is characterized in that the function is converted so as to be called according to the value of the function pointer variable instead of being called directly.

In the obfuscation method according to the present invention, a plurality of pointer variables to functions and array variables of pointers to functions are newly introduced into the source code of a given program. To any one of the function pointer variables or any of the plurality of function pointer array elements, any of the plurality of function pointer variables, any of the plurality of function pointer array elements, or the function address. It is characterized in that it is substituted and converted to call a function by the function pointer variable or the element of the function pointer array.

In the obfuscation method according to the present invention, pointer variables to a plurality of functions and a dummy function F are newly introduced into the source code of a given program, and inside the function F, , A plurality of function calls in the program can be executed via the function pointer variable, and each of the function calls in the program is converted to call a function F.

In the obfuscation method according to the present invention, a pointer variable to a function that returns a certain value and an array variable of a pointer to a function that returns a certain value are newly added to the source code of a given program. Introducing a plurality of elements, any of the plurality of function pointer variables or any of the plurality of function pointer array elements, any of the plurality of function pointer variables or the plurality of function pointer array elements , Or the address of the function,
A method for converting a function to be called by the function pointer variable or an element of the function pointer array, characterized in that the difficulty of the analysis is proved.

The obfuscation apparatus according to the present invention includes an input means for inputting a source code of a program described in a programming language capable of describing a function, a control means for controlling the entire obfuscation process, and the program. Means for deciding the area to be obfuscated by analyzing the source code of and the function pointer variable used for obfuscation, array variable of function pointer, dummy function, etc. An obfuscation unit for converting a function to be called using an array variable of the pointer or the dummy function, and a unit for outputting a source code or an executable program of the program obtained by obfuscating the program are provided. It is characterized by

The obfuscation processing recording medium according to the present invention is
A recording medium in which a program for obfuscating the source code of the program is recorded, the first processing of analyzing the source code of the program to determine an area to be obfuscated, and a function used for obfuscation A second process of introducing a pointer variable, an array variable of a function pointer, a dummy function or the like and converting the function pointer variable, the array variable of the function pointer or the dummy function to call a function, A computer-executable obfuscated program including a third process for outputting a source code or an executable program of the program obtained by obfuscating the program is recorded.

[0014]

BEST MODE FOR CARRYING OUT THE INVENTION Hereinafter, referring to the drawings, the overall configuration of the present invention and the following four embodiments (1) Obfuscated embodiment by a function pointer, (2) Obfuscated by an array of function pointers and function pointers An obfuscated embodiment using a dummy function that summarizes a function pointer and a function call, and (4) an obfuscated embodiment using a pointer to a function that returns a value and an array of pointers to a function that returns a value. An outline of what has been proved to be difficult to analyze will be described, and then details of each will be described.

FIG. 1 shows the entire structure of an obfuscation device to which the present invention is applied as an obfuscation device 110.

The obfuscation device 110 comprises an input unit 111, a central processing unit 112, an output unit 113, an obfuscation region determination unit 114, and an obfuscation processing unit 115.

The input unit 111 is for inputting a source code of a program to be obfuscated. The central processing unit 112 controls a process of determining a target to be obfuscated, a process of introducing a variable or a dummy function, a process of obfuscation, and the like.
The output unit 113 is for outputting an obfuscated source code or an executable program. After analyzing the source code, the obfuscation region determination unit 114 determines the obfuscation portion in the source code. Obfuscation processing unit 1
Reference numeral 15 newly introduces a function pointer variable used for obfuscation, an array variable of a function pointer, a dummy function, and the like, and uses them to obfuscate the source code of the program.

The above-described obfuscation device 110 is characterized by the following two processes.

(1) Obfuscation area determination process (2) Obfuscation process In the obfuscation target determination process, the source code of the program given from the central processing unit 112 is analyzed and the obfuscation target part is determined. The obfuscation process introduces a function pointer variable, an array variable of a function pointer, a dummy function, etc. used in the obfuscation process, and uses them to obfuscate the source code of the program. Hereinafter, these two processes will be described in detail.

First, the processing performed by the obfuscation area determination unit 114 will be described with reference to the obfuscation area determination flow chart of FIG. First, the source code of the program to be obfuscated is input from the input unit 111 (step 2
1). The central processing unit 112 sends this source code to the obfuscation region determination unit 114. The obfuscation area determination unit 114
Analyze the source code sent (Step 2
2). At this time, in general, the obfuscation area determination unit 114
Creates a flow graph, etc., and uses it to analyze the execution order including function calls, the usage of variables within and between functions, and the data flow. The obfuscation area determination unit 114 determines the target portion to be obfuscated using the information obtained by the process of step 22 (step 23). When the obfuscation area determination unit 114 determines the obfuscation area, it sends obfuscation area information including analysis information of the program to the central processing unit 112. The central processing unit 112 sends the obfuscated region information including the transmitted program analysis information to the obfuscation processing unit 115 (step 24), and the obfuscation region determination process ends.

Next, the obfuscation process will be described with reference to the obfuscation process flow chart of FIG. Obfuscation processing unit 115
Inputs obfuscated area information including program analysis information sent from the central processing unit 112 (step 3).
1). While referring to this information, the obfuscation processing unit 115
Obfuscates the source code of the given program. At this time, the obfuscation processing unit 115 newly introduces a plurality of function pointer variables, array variables of function pointers, dummy functions, etc. so as not to change the specifications of the program (step 32). After that processing, the obfuscation processing unit 115
Uses the function pointer variable, the array variable of the function pointer, the dummy function, or the like to create a sequence of command statements for selecting and calling a function from a plurality of functions (step 33). The obfuscation processing unit 115 removes the command statement relating to a part of the function call of the obfuscation area determined by the obfuscation area determination unit 114, so that the specification of the program is not changed so that the specification of the program is not changed. Insert a row (step 34). The sequence of instruction statements inserted here does not necessarily have to be inserted continuously unless the program specifications are changed. Then, if further obfuscation processing is required in step 35, the processing from step 32 is repeated. If not necessary, the obfuscation process ends.

Based on the above overall structure, the present invention obfuscates the source code of a given program. Here, in the obfuscation device 110, the input unit 111, the central processing unit 112, and the output unit 113 are common regardless of the embodiment, but the obfuscation region determination unit 114 and the obfuscation processing unit 115 are common. The contents of and may differ depending on the embodiment. As described above, these embodiments are the obfuscation embodiment by the function pointer, the obfuscation embodiment by the function pointer and the array of the function pointer, the obfuscation embodiment by the dummy function that summarizes the function pointer and the function call,
An obfuscated embodiment of a pointer to a function that returns a value and an array of pointers to a function that returns a value proves difficult to parse. Each of these will be described in detail below.

First, in order to make the explanation easy to understand, an obfuscation implementation using a function pointer, an obfuscation implementation using a function pointer and an array of function pointers, and an obfuscation implementation using a dummy function that summarizes function pointers and function calls FIG. 4 shows an example of the source code of the original program in the three embodiments, assuming that the source code is common. FIG. 4 shows step 23
5 is an explanatory diagram of obfuscation area determination processing in FIG.

The present invention is characterized by an obfuscation method in which a function is not directly called but is converted from a plurality of functions to call one function according to the value of a function pointer variable or the like. The obfuscation target is the imperative statement or the like that indirectly calls the imperative statement or function to be called (for example, depending on the value of a variable). In FIG. 4, the imperative sentence 41 and the imperative sentence 42 which are function calls are selected as the obfuscation area.

From here, the detailed description of each embodiment will be started. First, an obfuscation embodiment using a function pointer will be described step by step according to FIG.

FIG. 5 is a diagram of an obfuscated embodiment with a function pointer. In FIG. 5, the source code of the program shown in FIG. 4 is obfuscated by using a function pointer. 5, the same parts as those in FIG. 4 are designated by the same reference numerals. As described above, the obfuscation area determination unit 114 determines the command statements 41 and 42 as the obfuscation area, and the obfuscation area information including the program analysis information is stored in the central processing unit 11.
2 has been sent to the obfuscation processing unit 115.

At step 32, an instruction statement (variable declaration statement) 51 is provided so as not to change the specifications of the given program.
Has introduced the integer variable i, and the statement 5
In 2 a pointer variable f to a function is introduced.
At this time, the greater the number of variables used in determining the function to be called, the more difficult it is to determine the function to be called. Therefore, the number of pointer variables to the function and the like introduced in step 32 is large. Is desirable.

In step 33, the obfuscation processing unit 1
Reference numeral 15 creates a sequence of command statements that call different functions depending on the values of variables so as not to change the specifications of the program. One of the examples is a statement 53 and a statement 56. The imperative sentence 53 is the expression “i * (i + 1)% 2
== 0 "as a conditional expression, and when this conditional expression is satisfied, the address func1 of the function is assigned to the function pointer f (statement 54), and when that conditional expression is not satisfied, the function pointer f Is an if statement such that the function address func2 is substituted for (instruction statement 55). The command statement 56 is a command statement that calls and executes a function having the address stored in the function pointer f.

Next, in step 34, the command sentence 41 is arbitrarily selected from the portion determined as the obfuscation area,
The sequence of command statements (command statements 53 and 56) is replaced. The command statement 53 and the command statement 56 need not be continuously inserted unless the program specifications are changed.

Here, since the calculation expression "i * (i + 1)% 2" on the left side of the conditional expression of the if statement of the imperative statement 53 is equal to 0 at any (integer) value of i, the instruction is always executed. Sentence 5
Therefore, it can be said that the specifications of the program are not changed. Furthermore, since it is usually difficult to calculate the conditional expression in the if statement, it is difficult to determine the branch destination. More generally, it is known that the problem of determining the order of execution of imperative statements in a program is undecidable when there is a conditional branch. This point is described, for example, in “Undecidabi” by Landi.
"lity of Static Analysis",
ACM Letters on Programming
g Languages and Systems, V
ol. 1, No. 4, 1992, etc.

For the above reason, it is usually difficult to determine the value of f after executing the statement 53, and as a result, it becomes difficult to determine which function is called by f in the statement 56. Therefore, it can be said that the implementation of the present invention makes obfuscation that makes analysis between functions difficult.

Next, an obfuscation embodiment using a function pointer and an array of function pointers will be described step by step with reference to FIG.

FIG. 6 is a diagram of an obfuscated embodiment of a function pointer and an array of function pointers. In FIG. 6, the source code of the program shown in FIG. 6 is obfuscated by using a function pointer and an array of function pointers. In FIG. 6, the same parts as those in FIG. 4 are designated by the same reference numerals and arranged at the left end. As described above, the obfuscation area determination unit 114 determines the command statements 41 and 42 as the obfuscation area,
Information on the obfuscation region including the program analysis information is sent from the central processing unit 112 to the obfuscation processing unit 115.

In the obfuscation embodiment in FIG. 6, the obfuscation processing unit 115 first obfuscates the imperative sentence 41 among the imperative sentences selected by the obfuscation area determination unit 114 using a function pointer, and further, Obfuscated using an array of function pointers. In the embodiment in FIG. 6, among the above-described processing, the obfuscation processing using the function pointer is the same as the obfuscation embodiment using the function pointer, and is shown by the diagram arranged in the center of FIG. . In the central view of FIG. 6, the same parts as those in FIG. 5 are designated by the same reference numerals. At this stage, step 35 of the obfuscation process is executed.

Next, the process moves from step 35 to step 32, and the command statement 41 is used by using the array of function pointers.
The obfuscation of the part corresponding to is performed. For this purpose, first, at step 32, a new integer variable j is introduced in the statement 61, and further, an array A of function pointers is introduced in the statement 62. After that, the function pointer f is converted so as to be assigned via the function pointer array A. Therefore, in step 33, the statement 5
In the if statement corresponding to the if statement of No. 3, the assignment to the function pointer f in the instruction statement 54 is first assigned to one element A [33] of the array of the function pointers in the instruction statement 64. The if statement of the imperative statement 63 is created so that the substitution to the function pointer f in the statement 55 is first substituted into the element A [71] of the function pointer array in the imperative statement 65. Furthermore, as a second if statement, an instruction statement 66 whose conditional expression is “(j−1) * j% 2 == 0” is created, and in the instruction statement 67, an array of function pointer arrays Create an if statement such that one element A [33] is assigned to the function pointer f, and in the statement 68, one element A [71] of the array of function pointers is assigned to the function pointer f. There is. Next, in step 34, the statement created as described above and the statement 69 that calls and executes the function having the address stored in the function pointer f
Is replaced with the part corresponding to. It is not necessary to continuously insert the command statements inserted during these replacements as long as they do not change the program specifications.

Regarding the subscripts 33 and 71 in the elements A [33] and A [71] of the array of function pointers,
Any program may be selected as long as it does not change the specifications of the program. At that time, in order to enhance the effect of obfuscation, it is possible to use a complicated formula or the like for calculation.

At this time, since "(j-1) * j% 2" on the left side of the conditional expression of the if statement of the imperative statement 66 is equal to 0 at any (integer) value of j, it is always the imperative statement. 67 will be executed, and the specifications of the program will not be changed. In addition, "Compilers: Principles, by Aho, Sethi, Ullman, et al.
"Techniques and Tools", Add
It is known that it is generally difficult to calculate the elements of an array, as shown in a document such as ison-Wesley, 1986, and as described above, if
Since it can be said that it is difficult to calculate the flow of execution in a statement, normally two i
It becomes difficult to determine the value of f after execution of the f statement, and as a result, it becomes more difficult to determine which function is called by f in the imperative statement 69, and obfuscation that makes analysis between functions difficult. It can be said that it is done.

In the obfuscation embodiment using the function pointer and the array of function pointers described above,
It is not necessary to perform the obfuscation with the function pointer array after performing the obfuscation with the function pointer, and reversely, after performing the obfuscation with the address of the function assigned to the function pointer array, The address may be obfuscated with a function pointer. Of course, the above two obfuscations may be performed simultaneously.

Next, an obfuscation embodiment using a dummy function that summarizes the function pointer and the function call will be described step by step with reference to FIG.

FIG. 7 is a diagram of an obfuscated embodiment with a dummy function that summarizes function pointers and function calls. In FIG. 7, the source code of the program shown in FIG. 4 is obfuscated by using a dummy function that combines a function pointer and a function call. In FIG. 7, the same parts as those in FIG. 4 are designated by the same reference numerals and arranged at the left end. As described above, the obfuscation area determination unit 114 determines the command statements 41 and 42 as the obfuscation area, and the obfuscation area information including the program analysis information is transferred from the central processing unit 112 to the obfuscation processing unit 115. Have been sent to.

In the obfuscation embodiment in FIG. 7, the obfuscation processing unit 115 obfuscates the command statements 41 and 42 selected by the obfuscation area determination unit 114 using a function pointer, and further summarizes the function calls. It is obfuscated by using a dummy function. For this purpose, first in step 32, a new integer variable i is introduced in the statement 701, and a pointer f to a function is introduced in the statement 702. After that, in order to obfuscate using a dummy function that summarizes the function calls, the dummy function F is introduced in the command statement 703 (function declaration statement) in step 33. Inside the function F, the statement sentences 41 and 42 selected by the obfuscation area determination unit 114.
In order to be able to collectively call the function calls of the above, in the if statement of the statement 704, depending on the value of the variable i, when i is 0, the function address func1 is assigned to f in the statement 705. However, when i is 1, a command statement 706 is created in which the function address func2 is assigned to f. The statement 707 is for calling a function having the address stored in the function pointer f.

Further, in order to make the value of the variable i appropriate, a command statement 708 is created, and a command statement 709, which is a call to the function F, is created in the subsequent part of the command statement 708. Similarly, a command statement 710 is created and the command statement 710 is generated.
An instruction statement 711 that is a call to the function F is created in a portion subsequent to. Expression “i * (i + 1)% on the right side of the statement 708
In “2”, no matter what (integer) value i takes, the value i becomes 0 after execution of the statement 708. Similarly, the expression "(i-
1) * i% 2 + 1 ”, what is i (integer)?
The value of i becomes 1 after execution of the statement 710 because the value becomes equal to 1 when the value is taken. From the above, it can be said that there is no change in the specifications of the original program.

In step 34, the created function F and command statements 708 to 711 are replaced in correspondence with the command statements 41 and 42 selected by the obfuscation area determination unit 114. If the statement inserted during these replacements does not change the program specifications,
It is not necessary to insert continuously.

Here, the contents of the obfuscated embodiment in FIG. 7 will be described. When executing a program, when returning from a function call, execution of the program must move to the next statement after the called statement. For example, if the function F is called in the statement 709 of FIG. 7, and the function pointer f has the address of func1 in the statement 707 inside it, and func1 is called, the execution of the program returns from func1, The statement executed immediately after returning from the function F must be the next statement after the statement 709. Similarly, the function F is called in the imperative sentence 711, and the function pointer f is set to func in the imperative sentence 707.
If it has an address of 1 and func1 is called, the execution statement of the program returns from func1, and the statement executed immediately after returning from the function F is not the execution statement next to the statement 711. I won't. Considering this with a focus on the function func1, it means that the point after the function func1 is executed after the return depends on the calling position of the func1. Generally speaking, for the same reason that the problem of deciding the branch destination in the if statement is difficult, it can be said that it is difficult to decide the execution order of the correct call return as described above. It can be said that the obfuscation example increases the difficulty of the inter-function analysis.

Next, the obfuscation of an obfuscated embodiment using an array of pointers to a function that returns a value and an array of pointers to a function that returns a value, the difficulty of which is proved, will be described with reference to FIG.

However, since FIG. 8 is almost the same as FIG. 6 except that the function returns a value,
Keep the explanation to a minimum.

In the embodiment of FIG. 8, the source code of the program to be obfuscated is given in the leftmost drawing of FIG. The difference from the program in FIG. 6 is that the function func1 in FIG. 8 (declared by the statement 821)
The function func2 (declared by the statement 822) is a function that returns an integer value, and the statement 82
3 is that the return value of func1 is assigned to the variable m in 3 and the return value of func2 is assigned to the variable n in the statement 824.

In the embodiment of FIG. 8, the obfuscation area determination unit 114 selects the imperative sentences 823 and 824 as the target portions.

In the embodiment of FIG. 8, the obfuscation processing unit 1
Reference numeral 15 introduces a function pointer to obfuscate it. An embodiment of this process is shown in the central drawing of FIG. The difference between this embodiment and the embodiment of FIG. 6 is that in FIG. 8 a pointer f to a function that returns an (integer) value is introduced by the statement 832, and in the statement 836, f The point is that the return value of the function called via is assigned to m.

After the above processing, in the embodiment of FIG. 8, the obfuscation processing unit 115 introduces an array of pointers to functions that return an (integer) value, and obfuscates the function call through it. There is. The difference from the embodiment of FIG. 6 is that FIG.
Then, the statement 842 introduces an array A of pointers to functions that return (integer) values, and in the statement 849, the return value of the function called via f is m.
Is that it is assigned to.

The feature of the embodiment of FIG. 8 is the same as that described in FIG. 6, but the feature of FIG. 8 is that the difficulty of the analysis can be proved. More specifically, in a program in which there is an assignment using an array of function pointers for a pointer to a function that returns a value, and there is a call to a function by a pointer to a function that returns a value, It is shown that the problem of determining the address to point to is NP-hard. The proof is shown below.

Proof It is shown below that given an arbitrary 3-SAT problem, the problem can be reduced in polynomial time from the 3-SAT problem. 3-SAT problem is N
This proves that it is known to be P-complete. The proof will be specifically described below. This proof assumes that the analysis is performed assuming that all execution paths are feasible. This is an assumption that is usually made about parsing, "meet over all
Often called the "paths" assumption. Propositional variables v _i
Suppose for (i = 1,2, ..., m) a 3-SAT problem is given which examines the satisfiability of the logical product of n clauses. Here, the clause means three literals l _i1 ,
It is a logical sum of l _i2 and l _i3 (i = 1, ..., N). A literal is a certain k (1 ≦ k ≦ m),
v _k or its logical negation ¬v _k. Like this 3
When a SAT problem is given, construct a program including a function pointer as shown in FIG. The size of this program is obviously controlled by the polynomial order of propositional variables and formulas. Since it is assumed that all the execution paths of the if statement are executable, the conditional expression is omitted and "-" is omitted.
Is described. In this program, in L1,
Function pointer c and propositional variable v of the original 3-SAT problem
function pointer _v i (i = 1 corresponding to the _i,
2 ,. ． ． , M) is declared. Similarly, corresponding to the logical negation of propositional variable _{v i,} a function pointer Neg_v _i
Is declared. Furthermore, l _ij (i = 1,
2 ,. ． ． , N, j = 1, 2, 3) is j of the i-th clause.
Corresponding to the th literal, k (1 ≤ k ≤
For m), v _k or neg_v _k . Then, in L2, the function false () and the function tru
The address of e () is the array A of function pointers.
Substituted in [0] and A [1]. An arbitrary execution path in L3 in the program corresponds to the truth value assignment in the 3-SAT problem. That is, if 3-S
If the AT problem has a solution, then for every clause there is at least one literal that is true, and the corresponding function pointer l _ij in the program is the function t.
points to the address of rue (). Therefore, when the corresponding execution path is traced, at L5, the function pointer c
It can be seen that points to the function true (). Also, 3
-When there is no solution in the SAT problem, there is at least one clause in which all three literals are false. At that time, in L5 of the program, the function pointer c points to the function false (), and there is no execution path that points to true (). Conversely, when the function pointer c points to the function true () in L5 of the program, the given 3-SAT problem has a truth value assignment corresponding to the execution path. That is, 3
-The SAT problem has a solution. (End of proof)

As described above, it can be seen that the obfuscation embodiment by the array of the pointer to the function returning the value and the array of the pointer to the function returning the value proves the difficulty of the analysis. More specifically, it has proven difficult to determine the address pointed to by the function pointer. As a result, it becomes difficult to accurately determine the address that points to the function pointer by inter-function analysis or the like, and the program can be obfuscated.

As described above, according to the present embodiment, it is possible to make it difficult to specify the function to be called with an inexpensive configuration without changing the specifications of the original program. Analysis can be difficult. Further, it is a great feature of the present invention that the difficulty of analysis can be proved depending on the configuration. As described above, when a program has confidential data or a confidential algorithm, it is possible to prevent unauthorized access to the program with an inexpensive configuration.

[0055]

As described above, according to the present invention, when a program has confidential data or a confidential algorithm, the program can be obfuscated with an inexpensive structure so as to make inter-function analysis difficult. Therefore, it becomes possible to obfuscate the program by an obfuscation method and device that prove the difficulty of analysis of the obfuscated program depending on the configuration and prevent unauthorized access to the program. .

[Brief description of drawings]

FIG. 1 is a device configuration diagram showing an embodiment of the present invention.

FIG. 2 is a flowchart of obfuscation area determination processing.

FIG. 3 is a flowchart of obfuscation processing.

FIG. 4 is an explanatory diagram of obfuscation area determination processing.

FIG. 5 is an explanatory diagram of an obfuscation embodiment using a function pointer.

FIG. 6 is an illustration of an obfuscated embodiment with a function pointer and an array of function pointers.

FIG. 7 is an explanatory diagram of an obfuscation embodiment using a dummy function that summarizes a function pointer and a function call.

FIG. 8 is an explanatory diagram of an obfuscated embodiment in which a pointer to a function that returns a value and an array of pointers to a function that returns a value proves difficulty in analysis.

FIG. 9 is a proof diagram of the problem of determining the address of a function pointer.

[Explanation of symbols]

110 obfuscation device, 111 input unit, 112 central processing unit, 113 output unit, 114 obfuscation region determination unit, 1
15 Obfuscation processing unit.

Claims (6)

[Claims] 1. A method for converting a source code of a program written in a programming language capable of describing a function so as not to change the specifications of the program, wherein a plurality of pointer variables to the function are newly added. Introduce a plurality of instruction statements for substituting the address of the function into any of the function pointer variables, and call the function in the program to the value of the function pointer variable instead of directly calling the function. An obfuscation method characterized by converting to call a function accordingly. 2. A plurality of pointer variables to functions and array variables of pointers to functions are newly introduced to the source code of a given program, and any one of the plurality of function pointer variables is introduced. Alternatively, one of the plurality of function pointer arrays, any of the plurality of function pointer variables, or one of the plurality of function pointer arrays, or the address of a function is substituted, and the function pointer variable or the The obfuscation method according to claim 1, wherein conversion is performed so that a function is called by an element of a function pointer array. 3. A pointer variable to a plurality of functions and a dummy function F are newly introduced to the source code of a given program, and a plurality of functions in the program are provided inside the function F. The obfuscation method according to claim 1, characterized in that a function call can be executed via the function pointer variable and each of the function calls in the program is converted to call a function F. 4. A plurality of pointer variables to a function that returns a certain value and array variables of a pointer to a function that returns a certain value are newly introduced to the source code of a given program. Any of the function pointer variables or any of the plurality of function pointer array elements, any of the plurality of function pointer variables, any of the plurality of function pointer array elements, or the address of a function 3. A method of substituting a value into a function pointer variable or an element of the function pointer array and converting the function so that the function is called, and the difficulty of the analysis has been proved. Obfuscation method described in crab. 5. An input means for inputting a source code of a program written in a programming language capable of describing a function, a control means for controlling the entire process relating to obfuscation, and analyzing the source code of the program. A means for determining an area to be obfuscated, and a function pointer variable used for obfuscation, an array variable of a function pointer, a dummy function, etc. are introduced to introduce the function pointer variable, the array variable of the function pointer, or the dummy. Obfuscation means for converting a function to be called by using a function or the like, and means for outputting a source code or an executable program of the program obtained by obfuscating the program apparatus. 6. A recording medium in which a program for obfuscating the source code of the program is recorded, the first processing of analyzing the source code of the program to determine an area to be obfuscated, and the obfuscation. A function pointer variable, an array variable of a function pointer, a dummy function, etc. used for the above are introduced and conversion is performed so as to call a function using the function pointer variable, the array variable of the function pointer, the dummy function, etc. And a third process for outputting a source code or an executable program of the program obtained by obfuscating the program, and a computer-executable obfuscated program is recorded. Recording medium for obfuscation processing.