KR101747767B1 - Java automatic identifier renaming method - Google Patents
Java automatic identifier renaming method Download PDFInfo
- Publication number
- KR101747767B1 KR101747767B1 KR1020150142078A KR20150142078A KR101747767B1 KR 101747767 B1 KR101747767 B1 KR 101747767B1 KR 1020150142078 A KR1020150142078 A KR 1020150142078A KR 20150142078 A KR20150142078 A KR 20150142078A KR 101747767 B1 KR101747767 B1 KR 101747767B1
- Authority
- KR
- South Korea
- Prior art keywords
- token
- java
- signature
- variable name
- source code
- Prior art date
Links
- 238000000034 method Methods 0.000 title claims abstract description 93
- 238000004458 analytical method Methods 0.000 claims abstract description 21
- 230000008859 change Effects 0.000 claims description 17
- 238000006243 chemical reaction Methods 0.000 claims description 14
- 230000001131 transforming effect Effects 0.000 abstract 3
- 230000008901 benefit Effects 0.000 description 8
- 230000006870 function Effects 0.000 description 6
- 230000009466 transformation Effects 0.000 description 6
- 238000002474 experimental method Methods 0.000 description 4
- 230000006399 behavior Effects 0.000 description 3
- 239000000470 constituent Substances 0.000 description 3
- 238000010586 diagram Methods 0.000 description 3
- 230000000694 effects Effects 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 239000008186 active pharmaceutical agent Substances 0.000 description 2
- 230000002776 aggregation Effects 0.000 description 2
- 238000004220 aggregation Methods 0.000 description 2
- 238000010801 machine learning Methods 0.000 description 2
- 238000011160 research Methods 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 1
- 238000007796 conventional method Methods 0.000 description 1
- 230000003247 decreasing effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
- G06F21/121—Restricting unauthorised execution of programs
- G06F21/125—Restricting unauthorised execution of programs by manipulating the program code, e.g. source code, compiled code, interpreted code, machine code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
- G06F21/121—Restricting unauthorised execution of programs
- G06F21/128—Restricting unauthorised execution of programs involving web programs, i.e. using technology especially used in internet, generally interacting with a web browser, e.g. hypertext markup language [HTML], applets, java
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Computer Security & Cryptography (AREA)
- Theoretical Computer Science (AREA)
- Multimedia (AREA)
- Technology Law (AREA)
- Computer Hardware Design (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The present invention includes a signature generation step of classifying a class in an Oracle Java document, transforming associated classes into a representative class, and converting the class into a signature type using a method; The source code to be converted is read in byte units, the original source code is decomposed in token units, the token is stored in the collection of tokens, the byte format data is divided into tokens and specific characters, A source code analysis step of comparing the token with the secretary; If a token corresponding to the signature is found, invokes a surrounding token to confirm whether renaming is appropriate based on the signature, and if the surrounding token matches the signature, changes the variable name to an intuitive variable name And a transforming step of transforming the Java automatic identifier renaming method.
Description
The present invention relates to a Java automatic identifier renaming technique, and more particularly, to a Java automatic identifier renaming technique and a protection method that are sufficient for intuitively grasping an entire code and assist in code analysis.
A program written in the Java language is stored as a file converted into byte code when compiling the source code. And, when the saved file is executed, it is converted into machine language by the Java virtual machine. The bytecode, which acts as an intermediate language, is structured in such a way that the analyst can easily grasp the contents of the code. Because of these features, tools for converting bytecode back into the Java language are becoming popular. Because of this, various obfuscation techniques and tools have been developed and widely used to protect the source code and copyright of programs written in Java.
Meanwhile, with the spread of the Java language, malicious code made in the Java language is also increasing. Malicious code written in the Java language is also stored in byte code format, making it easy for analysts to analyze it. Therefore, many obfuscators use various obfuscation techniques to make analysis difficult. Malicious code analysts can easily convert malicious code written in Java into a Java language using a decompiler. However, since it is difficult to analyze by the obfuscation technique applied by the malicious code makers, or because there is no information about the variable name originally written in the bytecode, the decompiler has difficulty in restoring the variable name. Previously, it was not enough for collaborators to intuitively grasp the entire code when analyzing code written in the Java language. In addition, malicious code analysts can not predict behavior through variable names and can not help in the analysis.
SUMMARY OF THE INVENTION The present invention has been developed in order to solve the problems as described above, and it is an object of the present invention to provide a method and apparatus for analyzing a code written in Java language, which is sufficiently satisfactory for a collaborator to intuitively grasp the entire code, And to provide a new Java automatic identifier renaming technique and a protection method for solving the situation that disturbs the analysis by making it difficult to predict the behavior by changing the name.
According to another aspect of the present invention, there is provided a method for converting a Java class into a Java class, comprising the steps of: classifying classes in an Oracle Java document; The source code to be converted is read in byte units, the original source code is decomposed in token units, the token is stored in the collection of tokens, the byte format data is divided into tokens and specific characters, A source code analysis step of comparing the token with the secretary; Invoking a neighboring token to verify that renaming is appropriate based on the signature if the token matches the signature, and changing the surrounding token to an intuitive variable name if it is found that the neighboring token matches the signature; And a prototype implementation step of, if the token corresponding to the signature comes out after the entire source code is to be verified, and if the token is matched before and after the token and if all cases are matched, An identifier renaming technique and a protection method are provided.
The present invention relates to a method for intuitively finding variable names of obfuscated code or decompiled code written in Java language. Specifically, it divides the source code into tokens, and stores the condition part and the increment / decrement part of the API and the iteration statement as signatures in consideration of the characteristics of the Java language, and converts the variable names of the source codes into the names associated with the variables. Unlike traditional machine learning based research, there is an advantage of better accuracy because the Oracle Java API list is composed of signatures. In order to demonstrate the practicality of the present invention, a prototype was implemented, which resulted in a high renaming success rate of 73%. Therefore, when the renaming service is used based on the present invention, a collaborator can intuitively understand the role of each variable based on the variable name in a collaborative process, and the bytecode of the Java application is decompiled Applying it to one source code has the effect of reducing analysis time.
1 is a diagram showing an algorithm of a Java automatic identifier renaming technique according to an embodiment of the present invention;
Figs. 2 and 3 are diagrams showing before and after the renaming of the identifiers
Figs. 4 to 6 are diagrams showing the result of the renaming of the identifiers through the signature contrast. Fig.
Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. The objects, features and advantages of the present invention will be more readily understood by reference to the accompanying drawings and the following detailed description. In the following description of the present invention, a detailed description of known functions and configurations incorporated herein will be omitted when it may make the subject matter of the present invention rather unclear.
In describing the components of the present invention, terms such as first, second, A, B, (a), and (b) may be used. These terms are intended to distinguish the constituent elements from other constituent elements, and the terms do not limit the nature, order or order of the constituent elements. For example, if a component is described as being "connected", "coupled", or "connected" to another component, the component may be directly connected or connected to the other component, It is to be understood that other components may be "connected "," coupled "
Referring to the drawings, the Java automatic identifier renaming technique of the present invention includes a signature generation step, a source code analysis step, and a variable name conversion step. The signature generation step enumerates the classes shown in the Oracle Java document and converts the associated classes into a representative class by converting them into a representative class. In the source code analysis step, And divides the input source code source into tokens and stores them in a collection of tokens. Then, the data of the byte format is divided into tokens and specific characters and stored as a list. The stored tokens are compared with the secretaries, In the renaming step, if a token corresponding to the signature is found, the surrounding token is called to confirm whether renaming is proper based on the corresponding signature. If it is found that the surrounding token matches the signature, an intuitive variable name Change it. The present invention intuitively identifies variable names of obfuscated Java code. In other words, in order to change a variable name that does not have a precise meaning in the source code written in some Java language to a name suitable for the purpose of the variable, it is possible to infer the use of the variable against the signature and change it to an intuitively recognizable variable name. In the present invention, a method of converting a variable name is largely a method of changing a variable name based on a signature in which API information is stored, and a method of converting a variable name based on a condition part and an increase / decrease part constituting a loop statement. At this time, an application program interface (API) is a set of subroutines or functions that a program or application can invoke for processing in the operating system. A set of instructions is used to invoke an instruction when an application program needs to use the basic functions of the operating system. 1, the Java automatic identifier renaming technique of the present invention is shown in the form of an algorithm. The Java automatic identifier renaming technique of the present invention includes a program code input, a tokenization, a signature matching, Signature class serach, Token renaming, Last token determination, Renamed code output, and the like.
<Signature Generation Step>
Signatures are created by examining the list of Java APIs listed in the Oracle Java documentation. It lists the classes listed in the Oracle Java documentation and bundles the associated classes together into a representative class. For example, float, double, and integer specify num as the dominant class name, and string, stringbuffer, and stringbuilder set str as the dominant class name. And. List the methods of the classes contained in each representative class and remove duplicates. In the case of the compareTo of the representative class num and the compareTo of the representative class str, the previous token can not be precisely convinced, and therefore the same method as another representative class is also removed. Finally, we convert the remaining methods into signature types. The signature type is stored as {"representative class", "method", "condition"}. The condition is named as A in the case of pattern matching using methods, B in case of pattern matching in the condition part of the iteration, and C in case of pattern matching of the increasing / decreasing part of the iteration. The substring method of the string class can be {"str", "substring", "A"}.
<Source code analysis phase>
The present invention analyzes source code written in Java. First, the source code to be converted is read in byte units. Next, we perform the task of decomposing the input source code source in token units. A token points to a single character that makes up the source code. At this time, we exclude unnecessary characters to guess the use of variables and store them in the collection of tokens. (),,,,,,,,,,,,,,,,,,,,,, (CR), (HT), (SP), and (SP) of the specific characters are divided into a plurality of tokens, In this way, the byte-formatted data is divided into tokens and specific characters and stored as a list, and then the stored token is compared with the signature. API-based, and if a token matches the signature, make sure that the surrounding tokens are aligned for use with that signature.
<Variable name conversion step>
In the present invention, variable name conversion is performed according to pattern matching. First, when a token matches the signature, it invokes the surrounding token to verify that it is correct to rename it based on its signature. For example, if the source code a.b finds a match to the signature, make sure the preceding token is. And change the token a to an intuitive form of variable name using b. For example, if the token is stored in the order of variable.substring, and the current token check location is substring, match the stored substring and verify that the preceding token is. If both are matched, change the variable. In this case, rename variable to str so that it is intuitively known to be a string variable.
Next, add the numbering to the end of the changed token. Many variables are declared in the same class. In this case, if it is found using the same signature, it is changed to the same representative class name. At this time, renaming is performed with the distinguishable number added after the representative class name so that each variable can be identified. If multiple variables are used in the same class, the number is appended to the end of the token to avoid confusion.
The boundary and step signatures are additionally searched to indicate the iteration count and iteration step in the loop. If you encounter for while searching for tokens, you will know that it is the beginning of the loop. In the condition part of the for statement, there are cases where iterations are determined by comparing variables using inequality. At this time, if the next token in the inequality is a single variable name, not a number, change the next token to the boundary. If the current token and the next token are +, -, + =, - = in the increment / decrement part, confirm that monotone increase / decrease occurs and change the previous token to step. For example, if you have a source for (a = 0; a <b; a ++), you will find the beginning of the loop by encountering the for token. From the first; until the next; is the condition part. Change the b to a boundary because the inequality token <and the next token b are not numbers between them. second ; The next part is the increase / decrease part. If a + token appears in this part and the next token is concatenated with two tokens, change the previous token, a, to step because it is a monotone increase in ++.
FIGS. 2 and 3 show source codes before and after renumbering. Referring to FIG. 3, portions A, B, C, D, E, and F are renamed to A ', B', C ', D', E ', and F' that are intuitively recognizable prior to identifier renaming. It can be seen that the variable is renamed (converted) to an intuitively recognizable variable name. In FIG. 3, a portion indicated by a dotted rectangle is a portion renamed to an intuitively recognizable variable name. This allows collaborators to intuitively grasp the entire code when analyzing code written in the Java language.
<Performance Analysis>
In the present invention, time complexity is calculated for performance analysis. In the calculation, assume that the number of tokens obtained from the source code is n and the number of tokens to be changed by signature comparison is k. First, perform signature matching with all tokens obtained from the source code n times. We need to do n × k times because we need to perform n times to retrieve all tokens to change the token where the same signature is found, and since the number of tokens to change is k. Therefore, it represents the number of times of execution of n x k + n. It is O (n × n) if there is no or small enough signature found here, but O (n × n) because k = n if a signature is found for all tokens. In general, however, the time complexity is O (n) because the entire Java source code can not be part of the API information or condition in the loop.
<Step of Implementing Prototype>
The present invention includes a prototype implementation step of performing tokenization of the entire source code, then collating the token corresponding to the signature before and after the token, and performing conversion when all cases match. In the prototype implementation step, when a source code file name written in the Java language is input, the file is read in units of bytes. To make a read byte, a token is stored until there is a specific character. In contrast to signatures made from known patterns, when all tokens match, the variable is converted to an intuitively recognizable variable name.
Specifically, the prototype is implemented using the Java language, and the implemented source can be compiled and executed using eclipse (version eclipse-java-luna-SR1awin32-x86_64) program. When the executed prototype inputs the source code file name written in the Java language to be converted, the file is read in byte units. The bytes read are tokenized in the form of =,.,,,,,,,,,,,,,, (CR), (HT), (SP), and (SP) are stored as one token, and the characters other than (CR), (HT) Tokenize the entire source code and then convert it against the signatures made from known token patterns from the beginning of the token.The pattern can be built from the list of Java APIs listed in the Oracle Java documentation. If a matching token is found, it is checked before and after the token, and if all cases match, the converted name is converted into an intuitively recognizable name, such as num, str, To a num, str, file, or the like, which is intuitively recognizable, When analyzing code written in the Java language, collaborators can intuitively grasp the entire code.
On the other hand, it is possible to distinguish variables of the same class by appending a number to the end of the variable name to be converted. Classes of the same class are separated more reliably to avoid source code errors and analysis errors. Also, refer to the condition part of the for statement to perform variable name conversion. If the inequality is found in the condition statement of the for statement and the token next to the inequality is a non-numeric variable, change it to the variable name boundary that indicates the end of the iteration. If ++, -, + =, or - = appears in the increment part of the for statement, change the previous token to the variable name step indicating the step of the loop statement. Referring to FIG. 2 and FIG. 3, it can be seen that the renaming of the token is intuitively recognized as a variable name. Prototypes also allow collaborators to intuitively grasp the entire code when analyzing code written in the Java language. When the conversion is completed by checking to the end of the token, the result is output. (HT) of a new line is increased after (LF) output and (LF) is output, the token is output sequentially while reducing the number of (HT) of a new line after outputting (LF).
<Experimental Results>
For the experiment of the present invention, a signature composed of Java API list of Java official web site and condition part and increase part of for statement was made. And 45 examples of the well-known Java example site tutorialspoint were selected. The experimental results are shown in FIG. 4 and FIG. Analysis of the experimental results showed that the correct conversion was obtained when the token was the same as the signature. However, if you experimented with example source code with variables that do not use methods, you could not rename the variable names. As a result, identifier conversion was performed on 61 variables among 83 variables included in 45 examples. This means that the success rate in this experiment is 73%. As described above, since the present invention is based on an already-stored signature, unlike the conventional method, the variable name to be renamed has definite correct answers. Therefore, all renormalized variable names showed correct results in this experiment.
The present invention relates to a method for intuitively finding variable names of obfuscated code or decompiled code written in Java language. Specifically, it divides the source code into tokens, and stores the condition part and the increment / decrement part of the API and the iteration statement as signatures in consideration of the characteristics of the Java language, and converts the variable names of the source codes into the names associated with the variables. Unlike traditional machine learning based research, there is an advantage of better accuracy because the Oracle Java API list is composed of signatures.
In order to demonstrate the practicality of the Java identifier renaming technique according to the present invention, a prototype was implemented and an experiment was conducted using a credible example. As a result, the renaming success rate was 73%. Therefore, when the renaming service is used based on the present invention, a collaborator can intuitively understand the role of each variable based on the variable name in a collaborative process, and the bytecode of the Java application is decompiled Applying it to one source code has the effect of reducing analysis time.
According to another aspect of the present invention, there is provided a method of generating a signature, comprising: classifying a class in an Oracle Java document; converting a related class into a representative class and converting the class into a signature type using a method; The source code that is read in byte units and decomposed in the token unit of the input source code is stored in a collection of tokens. Then, the data of the byte format is divided into tokens and specific characters and stored as a list. Comprising the steps of: renaming each token in the form of an encrypted code to obfuscate the source code; providing a decryption routine to decompile the code to which the obfuscation technique is applied; Java that includes hide-and-hide API steps or API-wrapping steps An automatic identifier protection method is provided. The obfuscation technique employed in the Java automatic identifier protection method of the present invention can employ various obfuscation techniques such as an identifier conversion technique, a control flow obfuscation technique, a string obfuscation technique, an API concealment technique, and a class obfuscation technique .
The identifier conversion technique is intended to prevent the analysis by changing each identifier to a different meaning, a meaningless name, or a hard to understand name. The token selected from each token in the source code can be an identifier, and the token can be changed to a different meaning, meaningless name, or hard to understand name.
The control flow obfuscation technique is a control flow transformation in which an execution result of a program is the same, but an operation that complicates execution or a flow becomes complicated. A program has a variety of program flows even though the purpose of execution is the same. For example, you can call it when you call it, or you can put it inside a program without having to run it with a method call. This is called inline. There is also a way to outline the inverse of inline. There are aggregation, ordering, and computation if control flow obfuscation is classified in detail. First, the aggregation transformation is to change the function calling method of the above-mentioned inline and outline. The ordering transformation changes the order in which operations are performed. In other words, it is a technique to change the flow by changing the increment count to a decrement count, or by combining several loops into one. Computation transformation is a technique to insert dead or useless dead code into a program, to be.
The string obfuscation technique is a technique for obfuscating a string contained in a source code. That is, replace the string that exists in the bytecode with something that can be encrypted or recovered to the original string. Applying this technique has the effect of making analysts difficult to analyze by lowering code understanding. Another feature is that at the time of execution, the recovery routine must be included in the source code because it must eventually be restored to the original string.
The API hiding technique is utilized to hide sensitive libraries and methods. Java obfuscates the descriptor used for API calls and conceals the API. The Java Reflection API is used to correctly decode the obfuscated descriptor and call the API for the original purpose.
Class obfuscation techniques include class coalescing, class splitting, and type hiding obfuscation. First, class coalescing obfuscation is a program transformation that makes two or more classes of a program into one class. This obfuscation can replace all the classes used in the program into one class. Obfuscate object-oriented programs with procedural programs. Class splitting Obfuscation is a program transformation that makes one class of a program into many classes. There is an important point that should be decided when class is divided by considering the dependency relation among the members of class. Type hiding Obfuscation uses the Java interface concept to obscure the design intent. The feature of this obfuscation technique is that each interface that creates a given class contains only a small random subset of all the public methods in the class. For a reverse engineer trying to understand the functionality required of a particular object in a program, this obfuscation creates difficulties with many different types of objects representing the same object elsewhere in the code. It is to enhance security by preventing hackers from analyzing source code.
Considering that the obfuscated Java code can not be converted into source code using only the decompiler by applying the class obfuscation technique in the step of providing the decoding routine to decompile the code to which the obfuscation technique is applied, Decoding routines should be created and used to decompile code with obfuscation techniques.
It is also possible to bypass the present invention by hiding the API information. As a related technology, there is API hiding technique and API wrapping technique introduced above. API Wrapping is a technique to add a function that has the same function as a specific API to the code, rather than using the API directly. The API wrapping technique is a technique used by the executable file packer dummy. Dummy will change the binaries of already created executables, but if you apply this technique directly to the source code, you can also use it in the process of developing a program using the Java language. Therefore, it is advantageous that the source code of the application developed in Java can not be easily exposed to the hacker, and the code of the Java application can not be protected.
As a result, the Java automatic identifier renaming technique and the protection method according to the present invention are advantageous in that malicious code analysts, which have not been achieved so far, can easily convert malicious codes written in Java into a Java language and analyze them, The advantage of solving the problem of difficult analysis by the obfuscation technique applied by the makers, the advantage of preventing the decompiler from having difficulty in recovering the variable name because there is no information about the variable name originally written in the bytecode, The advantage of being able to grasp collaborator's intuitive whole code when analyzing code written in Java language is advantage that malicious code analyst can not predict behavior through variable name, The source code of the developed application is easily There is an advantage that can prevent a case that can be invoked.
The specific embodiments of the present invention have been described above. It is to be understood, however, that the scope and spirit of the present invention is not limited to these specific embodiments, and that various modifications and changes may be made without departing from the spirit of the present invention. If you have, you will understand.
Therefore, it should be understood that the above-described embodiments are provided so that those skilled in the art can fully understand the scope of the present invention. Therefore, it should be understood that the embodiments are to be considered in all respects as illustrative and not restrictive, The invention is only defined by the scope of the claims.
A, B, C, D, E, F. Some of the source code before renaming
A ', B', C ', D', E ', F'. Some of the source code after rememming
Claims (11)
A source code analysis step of decomposing the Java source code input by the source code analysis unit into tokens and generating a token list composed of a plurality of tokens; And
If a variable name changing unit detects one of the signature types corresponding to the tokens included in the token list among the plurality of signature types, the variable name indicated by the immediately preceding token, which is a token located immediately before the token, And a variable name conversion step of converting the Java automatic identifier into a variable name.
Wherein the variable name conversion step changes the variable name indicated by the immediately preceding token if the token included in the token list coincides with the method included in the detected signature format.
Wherein the variable name conversion step further changes a variable name indicated by at least one of a token located immediately after the inequality of the condition part and a token of the increase / A Java automatic identifier renaming technique.
Wherein each of the plurality of signature types generated in the signature generation step includes {"representative class", "method", "condition"}, and the condition is a character Wherein the Java automatic identifier renaming technique is characterized in that the Java automatic identifier renaming technique is named "
The above-
If the type of pattern matching is pattern matching using a method, A is used. If the type of pattern matching is pattern matching of the condition part of the loop statement, B is used. If the pattern matching type is pattern matching of the increase / decrease part of the loop statement, A Java automatic identifier renaming technique.
The source code analysis step
Receiving the Java source code;
Extracting a plurality of tokens included in the Java source code using a predetermined delimiter; And
Generating the token list using the extracted plurality of tokens
And a Java automatic identifier renaming technique.
The variable name conversion step
And renaming to a variable name generated based on the classification criterion of the representative class included in the detected one signature format.
And a predetermined serial number is added after the variable name changed by the predetermined rule.
A source code analysis unit for decomposing the input Java source code into token units and generating a token list composed of a plurality of tokens; And
When one of the signature types corresponding to the tokens included in the token list is detected among the plurality of signature types, a variable name change for changing a variable name indicated by the immediately preceding token, which is a token located immediately before the token, And a Java automatic identifier renaming unit.
Wherein the variable name changing unit changes the variable name indicated by the immediately preceding token if the token included in the token list coincides with the method included in the detected signature format.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR1020150142078A KR101747767B1 (en) | 2015-10-12 | 2015-10-12 | Java automatic identifier renaming method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR1020150142078A KR101747767B1 (en) | 2015-10-12 | 2015-10-12 | Java automatic identifier renaming method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| KR20170042896A KR20170042896A (en) | 2017-04-20 |
| KR101747767B1 true KR101747767B1 (en) | 2017-06-14 |
Family
ID=58705780
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| KR1020150142078A KR101747767B1 (en) | 2015-10-12 | 2015-10-12 | Java automatic identifier renaming method |
Country Status (1)
| Country | Link |
|---|---|
| KR (1) | KR101747767B1 (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2011096082A (en) | 2009-10-30 | 2011-05-12 | Hitachi Ltd | Program analyzing method, program analyzing program and program analyzer |
| JP5490101B2 (en) | 2008-05-08 | 2014-05-14 | ディスペース デジタル シグナル プロセッシング アンド コントロール エンジニアリング ゲゼルシャフト ミット ベシュレンクテル ハフツング | Method and apparatus for correcting information transmitted in digital form |
| KR101489606B1 (en) | 2013-12-12 | 2015-02-03 | 강원대학교산학협력단 | Method for detecting inconsistent code identifier and medium recording the same |
-
2015
- 2015-10-12 KR KR1020150142078A patent/KR101747767B1/en active IP Right Grant
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP5490101B2 (en) | 2008-05-08 | 2014-05-14 | ディスペース デジタル シグナル プロセッシング アンド コントロール エンジニアリング ゲゼルシャフト ミット ベシュレンクテル ハフツング | Method and apparatus for correcting information transmitted in digital form |
| JP2011096082A (en) | 2009-10-30 | 2011-05-12 | Hitachi Ltd | Program analyzing method, program analyzing program and program analyzer |
| KR101489606B1 (en) | 2013-12-12 | 2015-02-03 | 강원대학교산학협력단 | Method for detecting inconsistent code identifier and medium recording the same |
Also Published As
| Publication number | Publication date |
|---|---|
| KR20170042896A (en) | 2017-04-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN103761475B (en) | Method and device for detecting malicious code in intelligent terminal | |
| KR101521765B1 (en) | Apparatus For Code Obfuscation Using Indistinguishable Identifier Conversion and Method Thereof | |
| CN108595921B (en) | Method and device for confusing character strings in source codes | |
| US8589897B2 (en) | System and method for branch extraction obfuscation | |
| Chen et al. | Detecting android malware using clone detection | |
| KR101861341B1 (en) | Deobfuscation apparatus of application code and method of deobfuscating application code using the same | |
| CN108363911B (en) | Python script obfuscating and watermarking method and device | |
| CN106845171B (en) | Android application program code protection mechanism identification method | |
| CN103902910B (en) | Detect method and the device of malicious code in intelligent terminal | |
| CN105787305B (en) | A kind of method for protecting software for resisting semiology analysis and stain analysis | |
| Thomas et al. | Using automated fix generation to secure SQL statements | |
| CN101084478B (en) | Watermarking computer program code | |
| CN108509772B (en) | Source code reinforcement method and device based on execution sequence and single-point logic | |
| KR101234591B1 (en) | Method for Anti-Encoding Android by Using Java Native Interface | |
| CN104463002A (en) | APK reinforcing method and device and APK reinforcing client and server | |
| CN106778100B (en) | Obfuscation compiling method and obfuscation compiler based on android platform and IOS platform | |
| CN107967415A (en) | Resource obscures guard method, system and terminal installation | |
| CN103927164A (en) | Method and system for confusing scripts | |
| Drape | Obfuscation of Abstract Data− Types | |
| Kang et al. | Obfus: An obfuscation tool for software copyright and vulnerability protection | |
| Alam et al. | Droidnative: Semantic-based detection of android native code malware | |
| CN113282294A (en) | Android platform-based Java character string confusion method and device | |
| CN110147238B (en) | Program compiling method, device and system | |
| KR101747767B1 (en) | Java automatic identifier renaming method | |
| CN116611032A (en) | Method, system and storage medium for embedding and extracting software watermark in JAR package |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| A201 | Request for examination | ||
| N231 | Notification of change of applicant | ||
| E902 | Notification of reason for refusal | ||
| E701 | Decision to grant or registration of patent right | ||
| GRNT | Written decision to grant | ||
| N231 | Notification of change of applicant |