KR101851330B1 - Apparatus and method for detecting code reuse attack - Google Patents

Abstract

A code reuse attack detection apparatus and method thereof are disclosed. The attack detection device replaces the in-program call command with a first jump command that branches to a predefined trampoline area, creates a second jump command in the trampoline area that moves the call command to the trampoline area and branches to the next of the first jump command , Adding code for grasping the function information including the boundary of the function in the function of the program, and then adding the branch address of the indirect branch including the return via the debug architecture of the processor when the program is executed by the processor, Identify code reuse attacks by identifying execution flow information including addresses, function boundaries, and branch types.

Description

TECHNICAL FIELD [0001] The present invention relates to a code reuse attack detection apparatus,

The present invention relates to an apparatus and method for detecting a code reuse attack, and more particularly, to a method and apparatus for reusing existing code fragments by using return oriented programming (ROP) or jump oriented programming (JOP) The present invention relates to an apparatus and a method for detecting an attack.

As various mobile devices based on ARM (Advanced RISC Machine) became popular, various software based attacks aimed at these devices appeared.

(Write XOR eXecute) 방어 기술을 통해 방어되었다. The code insertion attack is to insert the code that the attacker intends to execute into memory while the attacking program executes, and modulate the execution flow so that the inserted code is executed. However,

(Write XOR eXecute) defense.

A code reuse attack (CRA), unlike the existing code injection attack, continuously executes small code fragments (gadgets) existing in a normal program through successive execution flow modulations so that an attacker can execute desired code will be. In this case, it can be divided into an ROP attack that modifies a return instruction and a JOP attack that modifies a jump instruction depending on the type of execution branch instruction modulated by the attacker.

Japanese Patent Application Laid-Open No. 10-2014-0114433

SUMMARY OF THE INVENTION It is an object of the present invention to provide an apparatus and method capable of easily detecting a code reuse attack using ROP or JOP.

According to another aspect of the present invention, there is provided a code reuse attack detecting method for replacing a program call command with a first jump command for branching to a designated trampoline region, Generating a second jump command to the trampoline region to branch to the next of the first jump command; Adding code for grasping function information including a boundary of the function in a function of the program;

Determining execution flow information including a destination address of an indirect branch including a return via the debug architecture of the processor when the program including the trampoline region and the function boundary identification code is added, ; And detecting a code reuse attack based on the execution flow information.

According to an aspect of the present invention, there is provided an apparatus for detecting a code reuse attack, the apparatus comprising: a processor configured to replace a program call command with a first jump command that branches to a designated trampoline area, A code generating unit for generating a second jump instruction for branching to the next jump instruction in the trampoline area and adding code for grasping function information including a boundary of the function in the function of the program; A PTM for identifying execution flow information including a destination address of an indirect branch including a return, a source address of a call command, and a function boundary through a debug architecture of a processor when executing a program to which the trampoline region and the function boundary identification code are added; Analysis section; And a CRA detection unit for detecting a code reuse attack based on the execution flow information.

According to the present invention, a code reuse attack using ROP or JOP can be easily detected. In addition, using hardware module technology and instrumentation technology, performance overhead can be reduced and it can be easily applied to existing mobile devices. In other words, since a hardware module that detects a real code reuse attack is connected through a host processor and a system bus, it can be applied without modification of the existing host processor. In the software construction technology, only a necessary information is extracted by a hardware module, .

1 is a diagram illustrating an example of an overall structure for detecting a code reuse attack according to the present invention;
FIG. 2 illustrates an example of a method for detecting a code reuse attack according to the present invention.
FIG. 3 illustrates an example of a method for newly constructing a program for detecting a code reuse attack according to the present invention.
FIG. 4 illustrates a configuration of an embodiment of an attack detection apparatus according to the present invention.
FIG. 5 illustrates an example of a detailed configuration of the CRA detection unit of FIG. 4 according to the present invention.
FIG. 6 is a diagram illustrating an example of combining signals input from two buffers by the combining unit of FIG. 4 according to the present invention,
7 is a flowchart illustrating a method of detecting a code reuse attack according to an embodiment of the present invention.

Hereinafter, an apparatus and method for detecting a code reuse attack according to the present invention will be described in detail with reference to the accompanying drawings.

FIG. 1 is a diagram illustrating an example of an overall structure for detecting a code reuse attack according to the present invention.

Referring to FIG. 1, an attack detection apparatus 110 for detecting a code reuse attack using ROP or JOP may be implemented as a subsystem in a system on-chip (SoC) platform. The attack detection device 110 is connected to the host processor 100 through the system bus 140 and directly connected to the debug architecture 108 of the host processor 100.

The host processor 100, the main memory 120, the memory controller 130, and the like may be implemented in various forms. For example, an ARM CPU can be used as the host processor. For convenience of explanation, it is assumed that the host processor is implemented as an ARM CPU. The ARM CPU includes a core 102 executing an application program, a debug trace architecture 108 a Program Trace Macrocell (PTM) 104, and a Trace Port Interface Unit (TPIU) 106. The PTM 104 and the TPIU 106 provide the attack tracer 110 with a branch trace of the program being performed in the core 102. There are various conventional methods by which the debug architecture 108 performs branch tracing of the program, so that a further explanation thereof will be omitted.

The attack detection apparatus 110 includes a PTM analysis unit 112 and a CRA detection unit 114. In order to reduce the amount of information provided to the attack detection device 110 from the host processor 100, the TPIU 106 provides a runtime trace to the attack detection device 110 in a high compression manner. The PTM analysis unit 112 receives and decompresses various branch tracking information obtained by the debug architecture from the TPIU 106 and the system bus 140, and transmits the analysis result to the CRA detection unit 114. The CRA detection unit 114 detects the code reuse attack by refining the branch trace.

FIG. 2 is a diagram illustrating an example of a method for detecting a code reuse attack according to the present invention.

1 and 2, when the host processor 100 calls the foo function in the program 200, the destination address of the return instruction of the foo function is the address 210 of the call instruction, call foo, This is normal. If the return command has a destination address other than the call command call foo (220), it can be said that there is an ROP attack.

Therefore, in order to detect an ROP attack, the attack detection device 110 copies the return address of all call instructions to a special stack called a shadow stack, and stores the value recovered from the top of the shadow stack and each Compare the destination address of the return instruction.

Unlike an ROP attack, a JOP attack uses an indirect jump or call to connect code fragments in a program and generate an attacker's desired code sequence. Therefore, instead of changing the return value stored in the stack, the JOP attack changes the indirect branch or jump destination address to a value indicating the code fragments for the attacker's desired code sequence. In general, when performing a normal program, the destination address of the calling function points to the function entry address, and the destination address of the indirect branch points to the address in the function to which the command belongs. For example, as shown in FIG. 2, if the destination address of the indirect branch instruction, inderect_jump, indicates the out-of-function 240, not the in-function 230, it is determined to be a non-ideal flow. Therefore, in order to detect a JOP attack, the attack detection apparatus 110 needs information such as a destination address of a call instruction, a destination address of an indirect jump, and a function boundary including a start and an end of a function.

The information needed to detect both ROP and JOP attacks is summarized as follows.

(1) Destination address of an indirect branch (for example, indirect call, indirect jump, return, etc.)

(2) Source address of the call command

(3) Function bounds

(4) Branch type for branch instruction classification

The attack detection device 110 can easily obtain the destination address of the indirect branch or the like through the debug architecture 108 of the host processor 100 among the above information for detecting the code reuse attack, it's difficult. The present embodiment includes a method for newly building a program binary to easily obtain the above information.

3 is a diagram illustrating an example of a method for newly constructing a program for detecting a code reuse attack according to the present invention.

3, when the program binary 300 is downloaded and stored in a local storage such as a disk or memory by the operating system (OS) kernel, the attack detection device 110 not only detects the destination address of the indirect branch, (Instrumented version) 310 in which a program binary is newly constructed in order to identify the type, the source address, and the like.

In more detail, the code builder (not shown) scans the program to find all function call instructions. Then, the code construction unit replaces the call instruction of the original program code with an indirect branch, and moves the call instruction to the pre-designated storage space 316. Hereinafter, the designated storage space 316 in which the call function of the original code is transferred is referred to as a trampoline. For example, in the case of the present embodiment, the function call command " call foo "302 is moved to the trampoline area 316 and on the original code with" call foo "Lt; RTI ID = 0.0 > 312 < / RTI > Call instructions 320 and 324, which are moved into the trampoline space 316, indicate the same destination address as the destination address indicated by the call instruction on the original code. The code builder also includes a direct branch (322, 326) after each call instruction (320, 324) that can be moved to the next address of where the call instruction originally existed in the original code, following the call instruction transferred to the trampoline.

If the memory size of one instruction is 4 bytes and the address of the start position of the trampoline 316 is A, then the position of the first call command (call foo) 320 transferred to the trampoline 316 is A, the address of the call bar 324 is A + 8 bytes (there are two commands (call foo, direct_jump) before the second call command). That is, the address of the nth call instruction is A + 8 * n, and the destination address of the return instruction of the function is A + 8 * n + 4, which is next to each call function. Since the start position of the trampoline 316 is known, the attack detection device 110 can easily classify the type of the branch instruction by simply checking the destination address received from the TPIU 106.

In particular, in the case of a paging command, the attack detection device 110 receives the destination address of the paging command from the TPIU 106 after an indirect jump to the trampoline. Thus, if the destination address follows an indirect jump, the attack detection device 110 regards the branch type as an indirect call, otherwise it is considered a direct call. All calls will be indicated by an indirect jump in the new build version (310 in FIG. 3). The source address of each call can be obtained based on the destination address of the indirect jump received from the TPIU 106 since the destination address of the indirect jump pointing to A + 8 * n becomes the source address of the call. And the correct destination address of the return instruction that needs to be maintained in the shadow stack (532 in FIG. 5) for ROP detection is the destination address and the next address of the indirect jump.

In order to detect a JOP attack, the attack detection device 110 inserts code 314, which grasps boundary information of each function, in each function. In the case of this embodiment, a store func_info code 314 for grasping the function boundary is added to the function foo. The code 314 for grasping the function boundary information stores the start address and the size of the function in the memory-mapped address of the hardware module through the system bus 140. The attack detection apparatus 110 can confirm the start position and size of each function by referring to a symbol table of an executable format having the same ELF (executable and linkable format).

In this embodiment, the code construction unit may be implemented as a part of the attack detection apparatus 110, or may be implemented in a separate configuration. The code building unit can be implemented in various forms such as hardware or software.

4 is a diagram illustrating a configuration of an embodiment of an attack detection apparatus according to the present invention.

4, the attack detection apparatus 110 includes a PTM analysis unit 112 and a CRA detection unit 420. The PTM analysis unit 112 includes a buffer unit 400 and a tracking unit 410 do.

To use the debug architecture 108 of the host processor 100, the buffer portion 400 receives the output signal of the debug architecture 108 directly. For example, referring to FIG. 1, the output signal of the TPIU 106 is routed directly to the buffer unit 400. In general, since the host processor 100 operates faster than other hardware devices, the buffer unit 400 temporarily stores the tracking information received from the TPIU 106. For example, the buffer unit 400 may be implemented as a first-in first-out (FIFO) type asynchronous buffer.

The tracking unit 410 analyzes the branch tracking information stored in the buffer unit 400 to determine the destination address of the indirect branch instruction and the direct branch direction. With this analysis information, the tracking unit 410 grasps the branch type and origin address of the call. For example, since all the call commands in the program are moved to the trampoline area as shown in FIG. 3 and each call command in the trampoline is indicated by an indirect branch in the program code, The type of the branch is identified as an indirect call, and the destination address of the indirect branch is regarded as the start address of the call command. The tracking unit 410 transmits each type and branch related information (for example, a source address of a call and a destination address of an indirect branch, etc.) to the CRA detection unit 114.

FIG. 5 is a diagram showing an example of the detailed configuration of the CRA detection unit 114 of FIG. 4 according to the present invention.

5, the CRA detection unit 114 includes two buffers 500 and 502, a coupling unit 510, a detection control unit 520, a stack manager 530, and the like.

The CRA detection unit 114 not only tracks the program execution of the host processor 100, but can also detect both ROP and JOP attacks. The CRA detection unit 114 uses the branch information provided by the PTM analysis unit 112 and the start address and the size information of the function input through the system bus 140 in order to determine whether a code reuse attack exists.

The first buffer 500 stores information received from the TPIU 106 and the second buffer 502 stores information received from the system bus 140. Both the first buffer 500 and the second buffer 502 may be implemented as FIFO buffers.

There is no limitation of the reception order between the information received from the TPIU 106 and the information received from the system bus 140. [ In other words, when the CRA detecting unit 114 receives the destination address of the indirect branch necessary for detecting a code reuse attack from the TPIU 106 but has not yet received the boundary information of the function from the system bus 140 And vice versa. Therefore, the CRA detection unit 114 performs a process of combining and rearranging the information received from the TPIU and the system bus, respectively, in order to track the original program sequence of the application through the combining unit 510.

The combining unit 510 combines the tracking information input from the two buffers 500 and 502 and grasps the execution mode of the original program. An example in which the combiner 510 combines the signals input from the two buffers is shown in FIG.

Referring to FIG. 6, when an application is started, the program flow encounters a function to be called first (for example, main ()). The function boundary information F.B0 and the like are transmitted to the second buffer 502 through the system bus 140 and the combining unit 510 receives the function of the first function to be called of the second buffer 502 When it is notified of reception of boundary information and the like, the operation is started (F.B0 (600) of FIG. 6).

At runtime, when the program encounters a call instruction (e.g., call foo in FIG. 3), code (314 in FIG. 3) for collecting function boundary information in a function prologue is performed and branch information Related information such as the branch type and the destination address) and function boundary information are transmitted from the PTM analysis unit 112 and the system bus 140, respectively. When events including such information are received and stored in the first buffer 500 or the second buffer 502, the combining unit 510 reads the events and performs an operation for combining.

If the function boundary information (F.B1) 602 is stored in the second buffer 502, the combining unit 510 receives a call related to the function boundary information stored in the second buffer 520 from the first buffer 500 And the like are received. When the first buffer 500 receives the information, the combining unit 510 checks the branch type 610 based on the branch-related information stored in the first buffer 500. If the first buffer 500 is a direct or indirect call, Combines the information (e.g., branch type, function boundary information, source address for direct call, etc.) (602 and 610, 616) received from the two buffers 500, 502. Otherwise, only information 612, 618 received from the first buffer is selected. The information is then transmitted to the detection control unit 520, which performs the final determination of the presence of a code reuse attack.

After the application is executed, the detection control unit 520 waits for the initial call function information supplied by the combining unit 510. [ Upon receiving the information, the detection control unit 520 calculates the start and end addresses (= start address + size) of the callee function and stores it in the first register 522 called FUNC_BOUNDS.

If the branch type coming from the combining unit 510 is another call, the detection control unit 520 obtains the start address and the size of another called function received from the combining unit 510. For example, in the case of an indirect call, if the destination address of the indirect call does not match the start position of the called function identified by the detection control unit 520, it means that the call can be jumped to an unknown address, Is a typical behavior seen by.

If the paging command is found to be a direct call or a good one, the detection control unit 520 pushes the return address (source address + 0x4) and FUNC_BOUNDS to the shadow call stack 532. The shadow call stack 532 maintains a shadow copy of the call stack of the host processor 100. The reason that FUNC_BOUNDS 522 is stored in stack 532 is that its value must be restored when the called function returns later.

The detection control unit 520 overwrites FUNC_BOUNDS 522 with the start and end addresses of the newly calculated called function after pushing to the shadow call stack 532. [ When the function is returned, the detection control unit 520 fetches the top entry of the stack and compares the return address of the return instruction received from the combining unit 510 with the stored return address. In the case of a mismatch, it means that the return address of the stack of the host processor 100 has been maliciously manipulated by an ROP attack, and the detection control unit 520 generates an interrupt.

If the destination address of the return instruction received from the combining unit 510 matches the return address stored in the shadow call stack 532, the detection control unit 520 outputs the FUNC_BOUNDS 522 to the function boundary information I write it back. If an indirect jump occurs in the host processor, the detection control unit 520 checks whether the destination address is within the start and end addresses of the current drive function referenced by the FUNC_BOUNDS 522. When the address indicates the outside of the function boundary, the detection control unit 520 regards the JOP attack and simultaneously generates an interrupt signal to notify the host processor 100 of the attack.

The shadow call stack 532 has a finite number of entries (e.g., 16). Therefore, if the destination application calls the nested function more than 16 times, it overflows. To overcome this limitation, a shadow stack manager 530 exists.

When the shadow call stack 532 is filled by the containment function, the stack manager 530 accesses the oldest eight entries via the AXI interface 560 in a predefined area (hereinafter referred to as a CRA area) 550 of the memory 120 ). And a register called VICTIM_ENTRY 534 temporarily stores the eight most recently evicted entries.

In addition, there may be exceptional cases where the same function is called repeatedly. To solve this problem, the detection control unit 520 includes a second register 524 for storing a counter value. When the same function is called in a series, the detection control unit 520 increments only the counter value of the second register 524 by 1 without pushing any value to the stack 532. If the function is returned and the REC_CNT 524 is a non-zero value, the detection control unit 520 decrements the counter value of the second register 524 by one instead of reading the top value of the stack 532. [

7 is a flowchart illustrating a method of detecting a code reuse attack according to an embodiment of the present invention.

Referring to FIG. 7, the attack detection apparatus replaces a call instruction in a program with a first jump instruction branching to a pre-designated trampoline area, moves the call instruction to the traffian area, Next, a second jump instruction to branch is generated (S700). In addition, a code for grasping the function information including the boundary of the function in the function of the program is added (S700).

When the program is executed by the host processor, the attack detection apparatus identifies the branch trace information including the destination address of the indirect branch including the return, the start address of the call instruction, the function boundary, and the branch type through the debug architecture of the processor (S710 ).

The attack detection apparatus detects a code reuse attack based on the branch trace information (S720).

The present invention can also be embodied as computer-readable codes on a computer-readable recording medium. A computer-readable recording medium includes all kinds of recording apparatuses in which data that can be read by a computer system is stored. Examples of the computer-readable recording medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage, and the like. The computer-readable recording medium may also be distributed over a networked computer system so that computer readable code can be stored and executed in a distributed manner.

The present invention has been described with reference to the preferred embodiments. It will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. Therefore, the disclosed embodiments should be considered in an illustrative rather than a restrictive sense. The scope of the present invention is defined by the appended claims rather than by the foregoing description, and all differences within the scope of equivalents thereof should be construed as being included in the present invention.

Claims (8)

Program in the trampoline region by replacing the program call command with a first jump command for branching to a predefined trampoline region and transferring the call command to the trampoline region and branching to the next of the first jump command step;
Adding function boundary detection code for grasping function information including a boundary of the function in a function of the program;
Determining branch trace information including a destination address of an indirect branch, a source address of a call, and a function boundary including a return through a debug architecture of the processor when executing the program to which the trampoline region and the function boundary identification code are added; And
And detecting a code reuse attack based on the branch trace information,
Wherein the detecting the replay attack comprises:
Storing the branch trace information in a first buffer;
Storing function boundary information received through a system bus in a second buffer;
Combining the branch trace information and the function boundary information of the second buffer if the branch type identified based on the branch trace information of the first buffer is a direct or indirect call; And
And analyzing a combination of the branch trace information and the function boundary information of the second buffer to detect a code reuse attack. The method as claimed in claim 1,
Detecting a return-based programming attack by comparing a destination address of the return instruction with a source address of the call; And
Based on the destination address of the call instruction, the destination address of the indirect jump instruction, and the boundary of the function, it detects jump-based programming attacks by determining whether the destination address of the call instruction is the start position of the function or whether the indirect jump within the function occurs within the function The attack detection method comprising the steps of: Program in the trampoline area by replacing the program call command with a first jump command branching to a predefined trampoline area, moving the call command to the trampoline area, and branching to the next of the first jump command A code building unit for adding a code for grasping function information including a boundary of the function in a function of the program;
A PTM analysis unit for obtaining branch tracing information including a destination address of an indirect branch, a source address of a call, and a function boundary including a return through a debug architecture of a processor when executing a program to which the trampoline region and function boundary identification code are added; ; And
And a CRA detection unit for detecting a code reuse attack based on the branch trace information,
Wherein the CRA detection unit comprises:
A first buffer for storing branch trace information received from the PTM analyzer;
A second buffer for storing function boundary information received via the system bus;
A combining unit for combining the branch trace information and the function boundary information of the second buffer if the branch type identified based on the branch tracking information of the first buffer is a direct or indirect call; And
And a detection control unit for analyzing the information of the combining unit and detecting a code reuse attack. delete The apparatus according to claim 3,
A first register for storing the start and end addresses of the called function when the function is called; And
And a second register for incrementing and storing the counter value by 1 every time the same function is repeatedly called and decrementing the counter value by 1 each time the counter value is returned,
Wherein the detection control unit detects whether the destination address of the indirect branch is out of the function boundary based on the start and end addresses of the function stored in the first register to detect whether the attack is an attack. 6. The method of claim 5,
And a shadow call stack for receiving and storing the value of the first register each time a function is called,
Wherein the detection control unit compares the value extracted from the top of the shadow call stack with a destination address of a return instruction when a return instruction is executed, and determines whether the attack is an attack. The method according to claim 6,
Further comprising: a stack manager for copying some values in the old order of the shadow call stack to a specific space in the memory when the shadow call stack is full. A computer-readable recording medium on which a program for performing the method of claim 1 is recorded.

Images