KR101228899B1 - Method and Apparatus for categorizing and analyzing Malicious Code Using Vector Calculation - Google Patents

Abstract

This technology is used to analyze and diagnose malicious codes using vector quantity calculation. According to one embodiment of the invention, the step of analyzing the binary code of the executable file, loading the analyzed binary code in the page unit of the two-dimensional structure in the memory, and in the analyzed binary code, branch instruction code (Opcode) and a vector value including a distance and a direction on a memory in page units of the two-dimensional structure from the identified binary position of the branch instruction code to the binary position of the branched instruction code. Calculating a matrix table; calculating a matrix table using the calculated vector value and the identified branch instruction code; calculating a hash value from the matrix; and calculating a different executable file based on the calculated hash value. Malicious nose using a vector amount calculation comprising the step of determining whether the same by comparing the hash value for It provides the classification and diagnosis. According to the present invention, it is possible to efficiently diagnose and classify executable files and malicious codes of the same type, and thus, it is possible to effectively manage signature resources.

Description

Method and Apparatus for Classification and Diagnosis of Malicious Code Using Vector Amount Calculation {Method and Apparatus for categorizing and analyzing Malicious Code Using Vector Calculation}

The present invention relates to a method and apparatus for classifying and diagnosing malicious codes. More specifically, the present invention relates to a method and apparatus for classifying and diagnosing malware of the same type by analyzing a binary of an executable file.

In general, modern malicious code is distributed by executing binary compression of Portable Executable (PE) file format through various compilers, and a large number of malicious codes are automatically generated for one original binary. It is reproduced and distributed in various binaries using. That is, attempts are made to evade analysis of specific malicious codes by obfuscating (encrypting) and distributing original binaries through various numbers of packers for one original binary.

At present, the generated malicious code must deal with the polymorphism diagnostic dedicated function (Heuristic or Generic) accordingly, which requires considerable time and effort for analysis and response.

One object of the present invention is to calculate a hash value by the method proposed by the present invention from an original malicious code binary, and also to be a test subject. The present invention provides a method and apparatus for calculating a hash value from the binary of a file and classifying and diagnosing malicious codes using the method.

Another object of the present invention is to detect execution when a binary file is loaded and executed in the memory of the system, and to diagnose and classify malicious code using the hash value of the binary file calculated by the method proposed by the present invention. And to provide a device.

Another object of the present invention is to provide a method and apparatus for diagnosing and classifying a binary file using a hash value of the binary file calculated by the method proposed by the present invention before the binary file is executed.

The object of the present invention is not limited to the above-mentioned object, and other objects that are not mentioned will be clearly understood by those skilled in the art from the following description.

According to an embodiment of the present invention for achieving the above object, in the method for classifying and diagnosing malicious codes using vector quantity calculation, analyzing binary code of an executable file, and analyzing the binary code in two dimensions Loading into memory in units of pages of the structure, identifying the branch instruction code (Opcode) in the analyzed binary code, and from the binary position of the identified branch instruction code to a binary position of the branched instruction code. Calculating a vector value including a distance and a direction on a page unit of a memory having a two-dimensional structure, calculating a matrix table using the calculated vector value and the identified branch instruction code; Calculating a hash value from the matrix and a different execution wave from which the calculated hash value is calculated As it compared with the hash value for a provides a classification and diagnosis of the infection by the vector quantity calculation comprises the step of determining whether or not the same.

The analyzing of the binary code of the executable file may include detecting whether the executable file is executed on a system through API hooking, and if the executable file is detected to be executed through the API hooking, executing the executable file. And disassembling and analyzing the binary code of the file from the code region on the system on which the executable file is executed.

In addition, analyzing the binary code of the executable file provides a method comprising disassembling and analyzing the binary code of the executable file before the executable file is executed on a system.

In addition, the executable file provides a method in which the executable file is compressed by a packer.

In addition, analyzing the binary code of the executable file provides a method for analyzing the binary code from an entry point location of the executable file or from a stub code API location used by a compiler.

In addition, the branch instruction code provides a method including any one of a forced branch instruction or a conditional branch instruction.

Further, the distance is a distance from one binary position on the page unit of the memory of the two-dimensional structure to the other binary position, the direction is higher depending on the size of the address value of the memory on the page unit of the memory of the two-dimensional structure Or a downward direction, wherein the distance is expressed as a difference between a memory address value of the one binary location and the other binary location.

Further, the distance is a distance from one binary position on the page unit of memory of the two-dimensional structure to another binary position, and the direction is another binary position on one binary position on the memory of the page unit of the two-dimensional structure It is expressed in a two-dimensional direction of, wherein the distance and the direction, respectively, represent the one binary position and the other binary position in two-dimensional coordinates, and provides a method calculated from these coordinates.

The calculating of the matrix table may further include storing the calculated vector value and the identified branch instruction code in a buffer up to a predetermined size, and calculating the hash value comprises storing the hash value in the buffer. It provides a method for calculating the hash value using a value.

The calculating of the matrix table may further include storing a direction of the calculated vector value and a set of identified branch instruction codes used to calculate the vector value in a first buffer in a byte format having a predetermined size; And storing the calculated size of the vector value in a second buffer in a byte format, and calculating the hash value using the values stored in the first buffer and the second buffer. Provide a method for calculating.

The method may further include storing the calculated hash value in a hash data signature database.

In addition, the calculated hash value is a hash value calculated from a binary code determined to be a malicious code, stored in a hash data signature database, and if the comparison result is the same, determining that the same type of malware is the same type of malware. It provides a method comprising more.

In addition, the calculated hash value provides a method of using any one of an identifier for a specific malicious code, an identifier for a packer (packer) that the executable file is compressed, and an identifier for the compiler that compiled the executable file. .

The calculating of the vector value may provide a method of sequentially calculating vector values of branch instruction codes according to an order in which branch instruction codes on binary codes of the executable file are executed.

In addition, when the branch instruction code on the binary code of the executable file is a branch instruction code that leaves the image area of the process of the executable file, the next calculation target branch instruction provides a method of setting a next branch instruction in the image area. .

According to another embodiment of the present invention, a computer readable recording medium having a computer program stored thereon, the computer program provides a computer readable recording medium which performs the above-described method when executed in a computer.

According to still another embodiment of the present invention, in the apparatus for classifying and diagnosing malicious codes using vector quantity calculation, a code analyzing unit for analyzing binary codes of executable files in units of pages having a two-dimensional structure, and the analyzed binary codes A code identification unit for identifying a branch instruction code, and a distance and a direction on a page-based memory of the two-dimensional structure from the identified binary position of the branch instruction code to a binary position of the branched instruction code. A vector calculation unit for calculating a vector value to be performed, a matrix table calculator for calculating a matrix table using the calculated vector value and the identified branch instruction code, a hash value calculator for calculating a hash value from the matrix, and Whether the calculated hash value is the same by comparing the calculated hash values for different executable files Using the vector quantity calculation including a determination of comparison provides a classification and diagnostic system for the malicious code.

The present invention also provides an apparatus further comprising a hash data signature database for storing the calculated hash value.

According to the method for classifying and diagnosing malicious codes according to the present invention, there is an effect of effectively diagnosing and classifying variant malicious codes for homogeneous malware of the same type.

In addition, according to the method for classifying and diagnosing malicious codes according to the present invention, it is possible to determine whether the malicious code is malicious code even if the signature does not have a signature, etc., and prepare for the operation.

In addition, according to the method for classifying and diagnosing malware according to the present invention, it is possible to efficiently manage signature resources.

In addition, according to the malicious code classification and diagnostic method according to the present invention, for example, there is an effect that can classify files produced by a specific compiler, a specific packer, and the like.

1 is a diagram illustrating an example of a memory loaded in units of pages by disassembling binary code of an executable file;
2 is a diagram illustrating an example of reconstructing instruction code by disassembling binary code of an executable file;
3 is a diagram illustrating an embodiment of a code routing vector table according to an embodiment of the present invention;
4 is a diagram showing a series of processes of a method for diagnosing and classifying malware according to an embodiment of the present invention;
5 is a diagram showing a schematic diagram of an apparatus for diagnosing and classifying malware according to an embodiment of the present invention;
6 is a diagram illustrating a schematic diagram of a code routing vector calculator according to an exemplary embodiment of the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS The features and advantages of the present invention and methods and systems for achieving the same can be more clearly understood with reference to the embodiments described below in detail in conjunction with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below and may be implemented in various other forms. In other words, the following examples are merely provided for a sufficient disclosure of the present invention and are not intended to limit the scope of the present invention. Also, like reference numerals refer to like elements throughout.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. It will be appreciated that the combination of each block in the accompanying block diagram and each step in the flowchart may be performed by computer program instructions. These computer program instructions may be mounted on a processor of a general purpose computer, special purpose computer, or other programmable data processing equipment such that instructions executed through the processor of the computer or other programmable data processing equipment may not be included in each block or flowchart of the block diagram. It will create means for performing the functions described in each step. These computer program instructions may be stored in a computer usable or computer readable memory that can be directed to a computer or other programmable data processing equipment to implement functionality in a particular manner, and thus the computer usable or computer readable memory. It is also possible for the instructions stored in to produce an article of manufacture containing instruction means for performing the functions described in each block or flowchart of each step of the block diagram. The computer program instructions It can also be mounted on a computer or other programmable data processing equipment, so a series of operating steps are performed on the computer or other programmable data processing equipment to create a computer-implemented process to perform the computer or other programmable data processing equipment. It is also possible for the instructions to provide steps for performing the functions described in each block of the block diagram and in each step of the flowchart.

In addition, each block or step may represent a portion of a module, segment or code that includes one or more executable instructions for executing a specified logical function (s). It should also be noted that in some alternative implementations, the functions noted in the blocks or steps may occur out of order. For example, the two blocks or steps shown in succession may in fact be executed substantially concurrently or the blocks or steps may sometimes be performed in the reverse order, depending on the functionality involved.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a diagram illustrating an example of a memory loaded in units of pages by disassembling binary code of an executable file.

As shown in FIG. 1, when disassembling the binary code of an executable file, each byte value is formed on a memory in two dimensions while forming one horizontal row in a predetermined unit (for example, 16 bytes). Is displayed. In the process of disassembling the binary code value, the binary code can be loaded into the system's memory to check its contents. In the case of Figure 1 it can be seen that the first row is displayed by forming a row of 16 bytes from the memory address 0100739D. In this way, it is possible to identify each instruction code (OPCode) that disassembles the binary code and constitutes a program therefrom. That is, for example, if you look at the shaded part in FIG. 1, the value E8 BF 01 00 00 is found in the memory. If you disassemble and interpret it as an instruction code, CALL 01 00 75 68, that is, address 01007568 in the memory You can see that it is a command code to call.

With respect to the analysis of binary code as seen in FIG. 1, the present invention relates to the CPU processing of the system for binary code of an executable file, the distance and direction of the binary location of the next code branched from the location of the current binary code. We propose a new scheme for calculating the CPU processing flow of target executable files by calculating (ie, vector values). Hereinafter, such an algorithm will be referred to as a code routing vector algorithm.

Referring back to FIG. 1, more specifically describing the code routing vector algorithm, as described above, the shaded binary code in FIG. 1 is a branch instruction code, and the CPU branches to the memory address 0x01007568 according to this instruction. Will execute the next command at that address. Thus, as shown by the arrows in FIG. 1, the relationship between the binary position of the next code branched from the current binary code position corresponding to the branch instruction code can be calculated in distance and direction, that is, as a vector. Thus, in analyzing the binary code of the executable file, the CPU processing flow can be illustrated as a vector. That is, the branch instruction code is identified as to which flow the CPU processing of the target executable flows, the next binary position branched by the branch instruction code is calculated as a vector value, and the process of calculating the vector value is executed. By processing the branch instruction code in the CPU, it is possible to express the flow of the CPU as vector values.

Branch instruction code is, for example, a mandatory branch instruction such as CALL, JMP, RET, etc., and a conditional branch instruction such as JNZ, as known to those skilled in the art. Instruction code that instructs the CPU to branch to a specific address in memory.

In this way, by identifying the branch instruction code in the binary code of the executable file and indicating the position of the binary code in which the branch instruction branches in a vector, the flow of CPU processing for executing the program can extract the characteristics of the target executable file. .

The extraction of the vector value from the code routing vector, that is, the calculation of the direction and the distance (size) value will be described as follows. For example, in a memory code that is displayed aligned in units of 0x1000 pages, a code routing vector value is based on a memory address value of each of the first binary code (branch instruction code) and the second binary code of a destination moved and branched therefrom. Can be determined.

According to an embodiment, in the case of the direction value, the direction value may be dualized based on whether each of the first binary code and the second binary code moves to an upper address or a lower address. have. In the case of a size (distance) value, the difference between the memory address values can be set to the size value.

According to another embodiment of the present invention, the X and Y coordinates may be calculated by randomly assigning the first binary code and the second binary code in a memory code that is displayed by being aligned in page units. More specifically, referring back to FIG. 1, the shaded CALL instruction code portion is the first binary code (branch instruction code), and the starting point of the branch instruction code (corresponding to 0x010073A5 in FIG. 1) is set as a reference point. Can be. The position branched by the CALL instruction code, 0x01007568, is a position that moves by 3 on the horizontal axis (X axis) and 28 on the vertical axis (Y axis) on the memory code of FIG. 1 arranged in two dimensions. That is, it can be mapped to move from (0,0) to (3, 28). By mapping the coordinates of the memory code two-dimensionally as described above, it is possible to express the direction and size values between the two coordinates as vectors. Those skilled in the art will appreciate that it is possible to set the first binary value to (0,0) as well as any coordinate value from which the vector value between the two coordinates can be obtained.

In such a code routing vector analysis, since the memory codes of binary codes are displayed in a predetermined page unit (for example, 0x1000 page units), it is guaranteed that the branching direction and the size are the same in any system. Therefore, the vector value calculated for the same executable file is constant, so that the CPU processing flow of the executable file can be identified.

2 is a diagram illustrating an example in which an instruction code is reassembled by disassembling binary code of an executable file.

Referring to Fig. 2, the instruction code shown in bold is the (forced) branch instruction code, and from these branch instruction codes, it is possible to calculate the vector amount through the above-described method. For example, the instruction marked ① is a CALL instruction and branches to the binary code at 0x01007568.

3 is a diagram illustrating an embodiment of a code routing vector table according to an embodiment of the present invention.

As described above, when the size and direction branched by the branch instruction code, that is, the vector value are digitized, the digitized value is stored in a predetermined buffer. In the case of a buffer, in FIG. 3, a corresponding instruction code (Opcode) and a direction value of a vector are inputted into a buffer (a shaded portion of the left buffer) and the size of the vector is processed into another buffer (a shade of the right buffer). Part). In this way, a vector value is calculated for one branch instruction, and the branch instruction code, the direction of the vector, and the size of the vector are input to the buffer as variables. In FIG. 3, the variable is stored in two buffers, but the present invention is not limited to the embodiment. That is, for example, it is also possible to store the above-described three variables (command code, direction, size) in one buffer, and it will be understood that the order of the variables stored in the buffer can be variously modified. Also, in FIG. 3, two bytes are used to indicate a code instruction and a direction, and four bytes are used to indicate a vector size, but it will be understood by those skilled in the art that the present disclosure is not limited to these values. .

Calculate vector values for branch instructions sequentially while analyzing binary code, and store them in a matrix table in buffers up to a predetermined capacity (for example, 1 Kbyte or 2 Kbytes). do. The hash value calculated in this way can be used as one identifier for identifying the target executable file. In the embodiment shown in Fig. 3, a hash value is calculated from two buffers (i.e., a buffer storing instruction codes and direction values and a buffer storing size values) as a code routing table and a vector size table. The invention is not limited only to these examples. For example, it is possible to calculate two hash values and combine them into one hash value.In contrast, the instruction code, direction, and size values are stored in one buffer and the hash value is calculated from one buffer. It is also possible.

In this way, when a hash value is calculated using a code routing vector for a specific executable file (for example, malicious code), the hash value can be used as a signature for identifying the executable file. Therefore, even if there is variant binary code obfuscated by various packers with respect to the original binary code, the processing flow performed by the CPU after the variant binary code is executed and loaded into memory can be expected to be the same. Variant codes can be classified and diagnosed.

In addition, even when the variant binary code is loaded into memory and not executed, if the binary code is obfuscated by the same packer or compiled by the same compiler, it can be expected to have the binary code of the same format up to a predetermined size. . In other words, even if the variant binary code is not actually executed, it is possible to classify files obfuscated by the same packer or files compiled by the same compiler.

In other words, by using the above code routing vector algorithm, it is possible to effectively diagnose and classify homogeneous malware of the same type, and even to identify and classify malicious code whose information is not known to antivirus companies, and thus, signature It is possible to manage resources efficiently. In addition, it is also possible to classify whether executable files including malicious code are files configured by, for example, the same compiler or the same packer according to a specific criterion.

Hereinafter, an embodiment of the present invention to which the above-described code routing vector is applied will be described.

4 is a diagram illustrating a series of processes of a method for diagnosing and classifying malware according to an embodiment of the present invention.

First, in step S400, the binary code of the target executable file is analyzed. According to one embodiment, the step of analyzing the binary code detects whether the executable file (eg, malicious code) is executed on the system through API hooking, and if the executable file is detected to be executed on the system through API hooking, Disassembling and analyzing the binary code of the executable file from a code region on the system on which the executable file is executed. That is, it detects whether the binary code is loaded and executed on the memory and analyzes the memory code therefrom. If the executable file is loaded in memory, it is the time when the executable file obfuscated by various packers is unpacked and actually starts to be executed on the system. Corresponds to the starting point. Alternatively, even when the target executable file is not executed on the system, the binary code in the non-executed state can be disassembled and analyzed. In this case, even if disassembled, the code may be different from the original binary code. However, as described above, when the code is obfuscated by the same packer or compiled by the same compiler, certain parts of the binary code have the same pattern. Therefore, it may be possible to diagnose and classify files from these features.

In addition, in the case of a reference point for starting analysis of binary code of an executable file, analysis may be started from an entry point of the executable file, or binary code may be analyzed from a stub code API location used by a compiler.

Next, in step S410, the binary code is analyzed to identify the branch instruction code according to the order in which the analyzed binary code is executed by the CPU. Specifically, the binary code is loaded into the memory in a two-dimensional page unit expressed in units of 0x1000 pages, for example, as shown in FIG. 1, from which branch instruction codes such as CALL, JMP, and RET are forced. Identifies conditional branch instruction code, such as

Next, from the binary position of the branch instruction code identified in step S420, a code routing vector value including a distance and a direction on the memory code in a page unit of a two-dimensional structure with respect to the binary position of the branching instruction code is calculated. do. In other words, to identify the processing flow on the CPU of the target executable file, the distance and direction with respect to the binary position of the next code branched from the binary code position of the branch instruction code are calculated. The distance value of the code routing vector may be expressed as a difference between the memory address values of the two binary locations. Alternatively, the two binary locations may be represented by two-dimensional coordinates and calculated mathematically from these coordinates. In addition, in the case of the direction value, it may be expressed by simply dualizing it to the upper side or the lower side according to the size of the memory address value. Alternatively, the two binary positions may be represented by two-dimensional coordinates and calculated mathematically from these coordinates. same.

Next, a code routing vector matrix table is calculated using the vector value (direction, distance) calculated in step S430 and the branch instruction code used to calculate the vector value. That is, as shown in FIG. 3, the code routing vector matrix table is generated by storing the direction of the instruction code and the vector and the size of the vector in a predetermined buffer. As described above, the matrix table may be generated as one buffer, or two buffers may be generated, and the instruction code and the direction of the vector may be stored as one set in one buffer and the size of the vector in another buffer. If so, it is also possible to store them in different combinations.

The calculated vector value and the branch instruction code used to calculate the vector value are stored in a buffer up to a predetermined size. That is, in accordance with the order in which the binary code of the target executable file is executed by the CPU, the code routing vector is calculated and repeated until a predetermined capacity is filled in the buffer (S440). It is apparent to those skilled in the art that the size of the buffer can be changed according to the situation.

Next, in step S450, a hash code (Hash Code, Hash Value) is calculated from the generated matrix table. A hash function or hash algorithm is a method of generating a kind of electronic fingerprint from arbitrary data. The calculated hash value is stored in a hash data signature database that stores the hash value and may be used as a DB for malware inspection later.

Next, in step S460, it is determined whether or not the same by comparing the hash value of the previously calculated and stored hash value of the target executable file. The same hash value means that the original binary code is the same, so it is possible to diagnose and classify the same type of binary.

The code routing vector algorithm described above may sequentially calculate the vector value for the branch instruction code while emulating the executable file according to the order in which the branch instruction code on the binary code of the executable file is executed. In other words, it is possible to sequentially determine the code that the executable file is processed by the actual CPU. This may be useful for diagnosing and classifying variant malware, considering that the malicious code obfuscated by various packers is executed by being decrypted with the original binary code when executed in a real process. However, there may be cases where the branch instruction code is a branch instruction that leaves the image area of the process of the executable. For example, there may be a case of using the resources of the system common area. In this case, the code routing vector value is calculated, but the memory code outside the image area of the process is no longer tracked, and the next branch instruction code in the process image area may be analyzed.

5 is a diagram illustrating a schematic diagram of an apparatus for diagnosing and classifying malware according to an embodiment of the present invention, and FIG. 6 is a diagram illustrating a schematic diagram of a code routing vector calculating unit according to an embodiment of the present invention.

The apparatus according to an embodiment of the present invention shown in FIG. 5 calculates a code routing vector and a hash value from the analyzed code and the code analyzer 500 analyzing the binary code of the executable file in units of pages of a two-dimensional structure. The code routing vector calculator 510 includes a database 530 that stores the calculated hash value, and a hash comparer 520 that compares the hash values.

As shown in FIG. 6, the code routing vector calculator 510 also branches from the analyzed binary code to a code identifier 511 identifying a branch instruction code and a binary position of the identified branch instruction code. A vector calculation unit 512 for calculating a vector value including a distance and a direction in a two-dimensional page memory for a binary position of the instruction code, and using the calculated vector value and the identified branch instruction code. A matrix table calculator 513 for calculating a matrix table and a hash value calculator 514 for calculating a hash value from a matrix may be further included.

More specifically, the code analysis unit 500 analyzes the binary code of the analysis target executable file. According to an embodiment, the code analysis unit 500 detects whether an executable file (eg, malicious code) is executed on the system through API hooking, and if it is detected that the executable file is executed on the system through API hooking, The binary code of the executable file is disassembled and analyzed from the code region on the system where the executable file is executed. Alternatively, the code analyzer 500 may disassemble and analyze the binary code in the unexecuted state even when the target executable file is not executed on the system.

The code identification unit 511 analyzes the binary code and identifies the branch instruction code in the order executed by the CPU. Specifically, the binary code is loaded into the memory in a two-dimensional page unit expressed in units of 0x1000 pages, for example, as shown in FIG. 1, from which branch instruction codes such as CALL, JMP, and RET are forced. Identifies conditional branch instruction code, such as

The vector calculation unit 512 calculates a code routing vector value including a distance and a direction on a two-dimensional page memory code with respect to the binary position of the branched instruction code from the binary position of the identified branch instruction code. do. Specific algorithms that can be used for such calculations are as described above, and repeated descriptions will be omitted, but will be understood by those skilled in the art.

The matrix table calculator 513 calculates a code routing vector matrix table using the calculated vector value (direction, distance) and the branch instruction code used to calculate the vector value. Details related to the matrix table are the same as described above, and repeated descriptions will be omitted, but will be understood by those skilled in the art.

The hash value calculator 514 calculates a hash code (Hash Code, Hash Value) from the generated matrix table.

The hash comparison unit 520 receives a hash value previously calculated and stored from the database 530, and compares the hash value with the hash value of the target executable file to determine whether the hash value is the same.

Embodiments of the present invention may be implemented in the form of programs that can be executed by various computer means to be recorded on a computer-readable recording medium. The computer readable recording medium may include program instructions, data files, data structures, etc. alone or in combination. The media may be those specially designed and constructed for the purposes of the present invention, or they may be of the kind well-known and available to those having skill in the computer software arts. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic-optical media such as floppy disks. magneto-optical media and hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, flash memory, and the like. Such a medium may be a transmission medium such as an optical or metal wire, a waveguide, or the like including a carrier wave for transmitting a signal specifying a program command, a data structure, or the like. Examples of program instructions include not only machine code generated by a compiler, but also high-level language code that can be executed by a computer using an interpreter or the like.

Although the embodiments of the present invention have been described above with reference to the accompanying drawings, those skilled in the art to which the present invention pertains may be embodied in various other forms without changing the technical spirit or essential features of the present invention. I can understand that. Therefore, the embodiments described above are illustrative in all respects and should not be understood as limiting.

500: code identification unit 510: code routing vector calculation unit 520: hash comparison unit 530: DB
511: code identifying unit 512: vector calculating unit 513: matrix table calculating unit
514: hash value calculation unit

Claims (18)

In the classification and diagnosis method of malicious code using vector quantity calculation,
Analyzing the binary code of the executable,
Loading the analyzed binary code into memory in units of pages of a two-dimensional structure;
Identifying a branch instruction code (Opcode) in the analyzed binary code,
Calculating a vector value from the identified binary position of the branch instruction code, the distance and direction on a page unit of memory of the two-dimensional structure, with respect to the binary position of the branched instruction code;
Calculating a matrix table using the calculated vector value and the identified branch instruction code;
Calculating a hash value from the matrix;
And comparing the calculated hash value with hash values of different calculated executable files to determine whether they are the same.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
Analyzing the binary code of the executable file,
Detecting whether the executable file is executed on a system through API hooking;
If it is detected that the executable file is executed through the API hooking, disassembling and analyzing the binary code of the executable file from a code region on the system on which the executable file is executed;
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1, wherein
Analyzing the binary code of the executable file,
Before the executable is executed on the system, disassembling and analyzing the binary code of the executable file.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The executable file is executable and compressed by a packer
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
Analyzing the binary code of the executable file,
Analyzing the binary code from an entry point location of the executable file or from a stub code API location used by a compiler;
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The branch instruction code includes one of a forced branch instruction or a conditional branch instruction.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The distance is a distance from one binary position on the page-based memory of the two-dimensional structure to another binary position, and the direction is an upward direction according to the size of the address value of the memory on the page-based memory of the two-dimensional structure or Expressed in one of the downward directions,
Wherein the distance is expressed as a difference between a memory address value of the one binary location and another binary location,
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The distance is a distance from one binary position on the page unit of memory of the two-dimensional structure to another binary position, and the direction is two of the other binary positions relative to one binary position on the memory of the page unit of the two-dimensional structure. Expressed in a dimensional direction,
The distance and the direction,
The one binary position and the other binary position are each represented by two-dimensional coordinates and calculated from these coordinates.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
Computing the matrix table
Storing the calculated vector value and the identified branch instruction code in a buffer up to a predetermined size;
The calculating of the hash value may include calculating the hash value by using a value stored in the buffer.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
Computing the matrix table
Storing in the first buffer a direction of the calculated vector value and a set of identified branch instruction codes used to calculate the vector value in a byte format of a predetermined size;
Storing the calculated size of the vector value in a second buffer in a byte format having a predetermined size;
Including,
The calculating of the hash value may include calculating the hash value by using values stored in the first buffer and the second buffer.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
And storing the calculated hash value in a hash data signature database.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The calculated hash value is a hash value calculated from a binary code determined to be malicious code, and is stored in a hash data signature database.
If the comparison results in the same, further comprising determining that the same type of homogeneous malicious code
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
The calculated hash value is used as one of an identifier for a specific malicious code, an identifier for a packer for compressing the executable file, and an identifier for a compiler for compiling the executable file.
Classification and diagnosis method of malicious code using vector quantity calculation.
The method of claim 1,
Computing the vector value
According to the order in which the branch instruction code on the binary code of the executable file is executed, the vector values for the branch instruction code are sequentially calculated.
Classification and diagnosis method of malicious code using vector quantity calculation.
15. The method of claim 14,
If the branch instruction code on the binary code of the executable file is a branch instruction code that leaves the image area of the process of the executable file, the next calculation target branch instruction is set to the next branch instruction in the image area.
Classification and diagnosis method of malicious code using vector quantity calculation.
A computer readable recording medium having a computer program stored thereon,
The computer program, when executed on a computer, performs the method according to any one of claims 1 to 15.
Computer-readable recording media.
In the apparatus for classifying and diagnosing malicious codes using vector quantity calculation,
A code analysis unit that analyzes binary code of an executable file in units of pages of a two-dimensional structure,
A code identifier for identifying a branch instruction code in the analyzed binary code,
A vector calculation unit for calculating a vector value including a distance and a direction on a page unit of a memory of a two-dimensional structure from a binary position of the branch instruction code identified to a binary position of a branching instruction code;
A matrix table calculator configured to calculate a matrix table using the calculated vector value and the identified branch instruction code;
A hash value calculator for calculating a hash value from the matrix;
Comprising a comparison unit for determining whether the same by comparing the calculated hash value with the calculated hash value for the different executable file;
Malicious code classification and diagnosis device using vector quantity calculation.
The method of claim 17,
And a hash data signature database for storing the calculated hash value.
Malicious code classification and diagnosis device using vector quantity calculation.

Images