WO2015117434A1

WO2015117434A1 - Method and device for manufacturing patch, and method and device for activating patch

Info

Publication number: WO2015117434A1
Application number: PCT/CN2014/090497
Authority: WO
Inventors: 蒋勇; 隆春; 王亮
Original assignee: 中兴通讯股份有限公司
Priority date: 2014-08-21
Filing date: 2014-11-06
Publication date: 2015-08-13
Also published as: CN105354045A

Abstract

A method and device for manufacturing a patch, a method and device for activating a patch, a corresponding program instruction and a carrier of the program instruction. The method for manufacturing a patch comprises: writing a patch script corresponding to at least one replaced code line into a source code where a patched function is located by using a script language, the patch script comprising a patch code corresponding to a replacing code and a position in the source code where a replaced code is located; generating a patch module for replacing the replaced code according to the patch script; and positioning at a start position and an end position of a corresponding instruction in a binary program according to the position in the source code where the replaced code is located, and adding same into the patch module. The method can solve the problem that when a relevant program is upgraded, the patch manufacturing is complex, and the repairing granularity is coarser, and the problem that a plurality of patched functions mutually refer to one another cannot be solved well.

Description

Patch manufacturing method and device, patch activation method and device

Technical field

The invention relates to the technical field of making and activating a patch, in particular to a method and a device for manufacturing a patch, a method and a device for activating a patch.

Background technique

Program online upgrade refers to the method of replacing the running code segment of the program without restarting the program during the running process, and is widely used in various high-reliability server operating systems.

Especially for industries with high requirements for software operation stability, such as financial telecommunications, it is necessary to complete the repair or update of system software errors without affecting the normal operation of the original business. The current program online upgrade patch is basically based on functions, you can fix the application by fixing the function that has a vulnerability or need to be updated.

The related technology adopts a function-level program repair method. The working principle is to replace the command of the patched function with the first instruction of the patched function to jump to the instruction in the replacement function, so that the program jumps to the position where the new function is located, when the replacement function is executed. After the execution is completed, jump back to the code that calls the old function, thus completing the entire calling process. See Chinese Patent Application Publication Nos. CN101937340A, CN103218262A, CN103744709A, CN103197942A. This function replacement has the following drawbacks:

1) The patching of this method is cumbersome. When making a patch, you need to copy all the macro definitions, structures, enumeration types, etc. that are referenced by the patch function;

2) The repair granularity of the program is relatively coarse, and the entire patched function needs to be replaced in order to solve a small problem;

3) This method cannot solve the problem that multiple patched functions are mutually referenced.

Summary of the invention

The main technical problem to be solved by the embodiments of the present invention is to provide a method and a device for manufacturing a patch, a method and a device for activating the patch, and to solve the problem of patching existing in the program upgrade of the related art. Trivial, the repair granularity is relatively thick and can not solve the problem of multiple referenced functions being mutually referenced.

In order to solve the above technical problems, the following technical solutions are adopted:

A method for manufacturing a patch includes the following steps:

Writing, by using a scripting language, a patch script corresponding to at least one line of the replaced code in the source code of the patched function, where the patch script includes a patch code corresponding to the replacement code and a position of the replaced code in the source code;

Generating a patch module that replaces the replaced code according to the patch script;

Positioning the start position and the end position of the corresponding instruction in the binary program according to the position of the replaced code in the source code, and adding the start position and the end position of the corresponding instruction in the binary program to the replaced code In the patch module.

Optionally, the step of generating a patch module that replaces the replaced code according to the patch script includes:

Converting the patch script into code of a predetermined type language and compiling it into a loadable kernel module;

The kernel module is compiled into a patch module in the form of a binary program.

Optionally, the predetermined type of language comprises a C language.

A method for activating a patch includes the following steps:

Obtaining a patch module, where the patch module includes a patch code corresponding to at least one line of the replaced code in the source code of the patched function, and a start position and an end position of the instruction corresponding to the replaced code in the binary program;

Setting a jump instruction for jumping to execute the patch code according to the start position, so that when the start position is executed, the jump instruction is executed to jump to execute the patch code in the patch module ;

According to the end position setting, after executing the patch code, returning to the patched function to continue running the code.

Optionally, the setting is used to jump to execute the patch code according to the start location. The steps to transfer instructions include:

The instruction to the start position is modified to jump to the jump instruction that executes the patch code.

Optionally, before the step of acquiring the patch module, the method further includes: installing a detection point and a return point of the patch module, where the detection point is the start position, and the return point is the end position; Associating the patch function to the probe point when the probe point is installed;

The step of modifying an instruction to execute the start position to a jump instruction for jumping to execute the patch code includes:

Modifying the detected instruction of the probe point to jump to a breakpoint instruction executing the patch code by a breakpoint exception handling function, such that when the probe point is executed, the breakpoint instruction is executed and passed The breakpoint exception handler jumps to execute the patch code in the patch module.

Optionally, the step of modifying the detected instruction of the probe point into a breakpoint instruction for executing the patch code by using a breakpoint exception handling function includes:

The probed instruction is backed up, and then the first one or more bytes in the probed instruction are replaced with a breakpoint instruction for executing the patch code by a breakpoint exception handling function.

A patch making device includes: a script editing module, a positioning module, and a patch generating module, wherein

The script editing module is configured to: write, by using a scripting language, a patch script corresponding to at least one line of the replaced code in the source code of the patched function, where the patch script includes the patch code corresponding to the replaced code and the replaced code is The location in the source code;

The patch generation module is configured to: generate a patch module that replaces the replaced code according to the patch script;

The positioning module is configured to: locate a start position and an end position of the corresponding instruction in the binary program according to the position of the replaced code in the source code, and place the replaced code in the binary program corresponding to the instruction The start location and the end location are added to the patch module.

Optionally, the patch generation module includes: a script language translator and a patch module compiler, where

The scripting language translator is configured to: convert the patch script into code of a predetermined type language and compile into a loadable kernel module;

The patch module compiler is configured to: compile the kernel module into a patch module in the form of a binary program.

A patch activation device includes an acquisition module, an instruction setting module, and a return setting module, wherein

The obtaining module is configured to: acquire a patch module, where the patch module includes a patch code corresponding to at least one row of the replaced code in the source code of the patched function, and a start position and an end of the command corresponding to the replaced code in the binary program. position;

The instruction setting module is configured to: set a jump instruction for jumping to execute the patch code according to the start position, so that when the start position is executed, the jump instruction is executed to jump to execution Patch code in the patch module;

The returning device module is configured to: return to the patched function to continue running the code after executing the patch code according to the ending location setting.

Optionally, the instruction setting module is configured to set a jump instruction for jumping to execute the patch code according to the start position according to the following manner:

Optionally, the apparatus further includes a mounting module, wherein:

The installation module is configured to: install a detection point and a return point of the patch module, the detection point is the start position, the return point is the end position, and when the probe point is installed, A patch function is associated with the probe point;

The instruction setting module is configured to: modify the detected instruction of the probe point to jump to a breakpoint instruction for executing the patch code by a breakpoint exception handling function, such that when the probe point is executed, The breakpoint instruction is run and jumps to execute the patch code in the patch module by a breakpoint exception handler.

Optionally, the instruction setting module is configured to: back up the detected instruction, and then The first one or more bytes in the probe instruction are replaced with a breakpoint instruction for executing the patch code by the breakpoint exception handling function.

A computer program comprising program instructions that, when executed by a computer, cause the computer to perform any of the above-described patching methods.

A carrier carrying the above computer program.

A computer program comprising program instructions that, when executed by a computer, cause the computer to perform any of the patch activation methods described above.

A carrier carrying the above computer program.

The beneficial effects of the technical solution of the present invention are:

The technical solution of the present invention provides a method and a device for manufacturing a patch, a method and a device for activating a patch, which can replace one or more lines of code in a source code of a patched function, thereby implementing an upgrade or repair of the software program; The patching method of the embodiment of the present invention includes: using a scripting language to write a patch script corresponding to at least one row of the replaced code in the source code of the patched function, the patch script including the patch code corresponding to the replacement code and the replaced a location of the code in the source code; generating, according to the patch script, a patch module that replaces the replaced code; and positioning a position of the replaced code in the source code to a start position of a corresponding instruction in the binary program according to the location of the replaced code And ending the location, and adding to the patch module; the method of the embodiment of the present invention may generate a patch for one or more lines of code in the source code, and use the patch to replace one or more lines of code in the function source code. To achieve an upgrade to the software; since it is a patch for the code line Therefore, the manufacturing process is simple and fast, and the software is upgraded by applying the patch created by the embodiment of the invention, so as to avoid replacing the entire function for a small problem, reducing the granularity of repairing the program, and additionally applying the manufacturing method of the embodiment of the present invention. Patch can upgrade multiple functions in the original program online, without considering the mutual calling relationship between multiple functions; Compared, it can improve the efficiency of software upgrade, reduce the complexity of patch production, and improve the security and reliability of patch upgrade.

Corresponding to the patch module created by the foregoing method, the embodiment of the present invention further provides a method for deactivating a patch, which can activate a patch module created by using the foregoing manufacturing method to implement replacement of one or more lines of code in the source code; The method for deactivating a patch of an embodiment includes: acquiring a patch module, where the patch module includes a patch code corresponding to at least one line of the replaced code in the source code of the patched function, and a start of the instruction corresponding to the replaced code in the binary program. a position and an end position; setting, according to the start position, a jump instruction for jumping to execute the patch code, such that when the execution to the start position is performed, the jump instruction is executed to jump to execute the patch module a patch code; after the execution of the patch code, returning to the patched function to continue running code according to the end position; using the activation method of the embodiment of the present invention, when the kernel runs to a starting position, the operating station The jump instruction jumps to execute the patch code in the patch module, and implements the software in the Stage process can be substituted for one or more lines of code.

BRIEF abstract

1 is a schematic flowchart of a method for manufacturing a patch according to Embodiment 1 of the present invention;

2 is a schematic diagram of a specific processing procedure of a patch script according to Embodiment 1 of the present invention;

3 is a schematic flowchart of a method for activating a patch according to Embodiment 2 of the present invention;

FIG. 4 is a schematic flowchart of a program upgrade according to an activation method of the embodiment provided by Embodiment 2 of the present invention;

FIG. 5 is a schematic structural diagram of an online software upgrade method according to Embodiment 3 of the present invention; FIG.

FIG. 6 is a schematic structural diagram of a device for fabricating a patch according to Embodiment 4 of the present invention; FIG.

FIG. 7 is a schematic structural diagram of another apparatus for fabricating a patch according to Embodiment 4 of the present invention; FIG.

FIG. 8 is a schematic structural diagram of a patch activation apparatus according to Embodiment 5 of the present invention; FIG.

FIG. 9 is a schematic structural diagram of another apparatus for activating a patch according to Embodiment 5 of the present invention.

Preferred embodiment of the invention

The present invention will be further described in detail below with reference to the accompanying drawings.

Embodiment 1:

Considering the program upgrade of the related function level replacement method, the patch preparation is cumbersome, the repair granularity is relatively coarse, and the problem that multiple patched functions are mutually referenced cannot be well solved; the embodiment of the present invention proposes to upgrade one or more lines of code in the software. The code line level replacement mode is upgraded. In order to achieve this, the embodiment provides a method for manufacturing a patch, as shown in FIG. 1 , including the following steps:

Step 101: Write, by using a scripting language, a patch script corresponding to at least one line of the replaced code line in the source code of the patched function, where the patch script includes the patch code corresponding to the replacement code and the replaced code in the source code. s position.

The method in this embodiment uses a scripting language to write a patch. In the prepared patch script, there are various data types and control structures. In the patch script, all local variables and global variables that can be accessed in the patched function can be accessed, and the patch is patched. All structures that are accessible in the function. The script can access all the global functions and static functions in the original program.

Optionally, the patch scripting language uses a scripting language similar to the interpretation, which uses three data types—integers, strings, and associative arrays—that have complete control structures, including code blocks, conditions, loops, and functions. . Variables do not need to declare a type and can be automatically guessed and checked against the context.

In this embodiment, the patch script consists of a probe and a patch code and a probe that need to be executed when the probe is triggered; and the probe specifies the range of the code segment to be replaced, that is, the start position of the replacement code in the source code and End position. For example, the following describes a patch script in which the probe specifies the range of code segments to be replaced, from page 3 of the page_alloc.c file to the code of 3341;

Kernel.statement("*@mm/page_alloc.c:3336").end("*@mm/page_alloc.c:3341")

Following the probe is the patch code to be used, which will replace the code from line 3336 of the page_alloc.c file to 3341.

The scripting language also provides all the necessary operators similar to those commonly used in the C language, and the usage is the same, with arithmetic operators, binary operators, assignment operators, and pointer obsolescence, including string concatenation, associative array elements, and merges. Operator.

Step 102: Generate a patch module that replaces the replaced code according to the patch script.

Step 103: Position a position of the replaced code in the source code to a start position and an end position of a corresponding instruction in the binary program, and add a start position and an end position of the corresponding instruction to the patch module.

The method of the embodiment can use the position of the replaced code in the source code to locate the start position and the end position of the corresponding instruction of the binary program, and then add the start position and the end position of the corresponding instruction to the patch module. The start position and the end position in this embodiment refer to the start address and the end address of the instruction.

In the method patch script of this embodiment, the start address and the end address in the source code are specified, and after the patch location module is converted, the start address and the end address specified in the script are converted into a start address and an end address in the binary program, and then saved. In the code of the patch module.

Optionally, the process of locating the start position and the end position of the instruction includes: parsing the patch script, and then obtaining a start position and an end position of the corresponding instruction in the binary program according to the position of the replaced code line in the patch script, and finally synthesizing to the patch module. in. For example, the code of the page_alloc.c file 3336 line 3341 in the binary program corresponds to the instruction start address stext+0x12adad, and the end address is pc=_stext+0x12add0, so the above-mentioned patch for the code segment of the page_alloc.c file 3336 line 3341 may include The following:

Kernel.statement("build_all_zonelists@mm/page_alloc.c:3336")/*pc=_stext+0x12adad*/.end("build_all_zonelists@mm/page_alloc.c:3343")/*pc=_stext+0x12add0*/

The patch module generated by the method of the embodiment includes at least: a position of the replaced code in the source code to locate a start position and an end position of the corresponding instruction in the binary program, and a patch code.

The method provided in this embodiment can generate a patch for one or more lines of code in the source code. This patch can be used to replace one or more lines of code in the function source code to implement software upgrade; since the patch is made for the code line, the production process is simple and fast, and the software created by the invention is upgraded. Avoid replacing the entire function for a small problem, reducing the granularity of the repair of the program; in addition, applying the patch made by the method of the present invention can perform online upgrade of multiple functions in the original program, without considering the relationship between multiple functions. Mutual call relationship; compared with related technologies, it can improve the efficiency of software upgrade, reduce the complexity of patch production, and improve the security and reliability of patch upgrade.

Optionally, the foregoing step 102 may include:

For example, the patch script is translated into the C language code, and then the C language code is compiled and linked to generate a loadable kernel module; finally, the kernel module is compiled into a patch module in the form of a binary program. The patch module thus generated can be upgraded by the kernel. Similarly, the patch script corresponding to the above page_alloc.c file 3336 line 3341 is taken as an example. After the script is converted into a C language code, the specific contents are as follows:

Finally, the above C language code is compiled into an executable binary program.

As shown in FIG. 2, the specific processing procedure of the patch script in the method of this embodiment may include:

Step 201: Parse the patch script. The scripting language uses a scripting language similar to awk. The script parsing phase mainly checks whether the input script has syntax errors, such as whether the braces match, whether the variable definition is normal, etc.; also checks the security of the script.

Step 202: Expand the function defined in the patch script according to the script library.

This stage is mainly to expand the probe points defined in the patch script or the functions used. It is not only necessary to expand the predefined script library, but also to analyze the debugging information of the kernel or kernel module. At this stage, it is necessary to determine the instruction address of the probe point and the return point.

Step 203: Translate the expanded script into a C file and compile the C file into a loadable kernel module.

At this stage, the expanded script is converted to a C file. Optionally, when the script is translated into C language, the function call in the script needs to be converted into a function call of the kernel, and the C code is compiled and linked to generate a loadable kernel module.

Step 204: Compile the translated C file into an executable binary program.

Alternatively, the translated C code can be compiled into an executable binary program through a binary tool chain included in the system; in addition, it is linked with the script library runtime library function during compilation. The binary generated by this step is the patch module. The start and end addresses in the binary that are located on the replacement code can then be added to the patch module.

Through the process shown in Figure 2, a binary patch module can be created that can be used by all cores for software upgrades.

Embodiment 2:

As shown in FIG. 3, this embodiment provides a method for activating a patch, and the patch module generated in the first embodiment is activated to replace the code line in the original patched function. Optionally, the activation method includes the following steps. :

Step 301: Obtain a patch module, where the patch module includes the source code of the patched function. At least one line of the patch code corresponding to the replaced code and the start position and the end position of the corresponding instruction of the replaced code in the binary program.

Step 302: Set a jump instruction for jumping to execute the patch code according to the start position, so that when the start position is executed, the jump instruction is executed to jump to execute the patch module. Patch code.

Step 303: Return to the patched function to continue running the code after executing the patch code according to the end position setting.

The activation method of this embodiment may set a proxy in the kernel to complete the above steps. The working mechanism of the stub proxy is: when the kernel executes to the start address of the replaced code in the binary program, the jump instruction jumps. To the patch code that executes the replaced code; when the kernel executes the patch code, it returns to the original function and continues to run the code according to the end address of the replaced code in the binary program.

With the activation method of this embodiment, one or more lines of code in the patched function can be replaced, thereby implementing the program upgrade or repair.

Optionally, the process of jumping to the execution of the jump instruction of the patch code according to the start position in step 303 may include: modifying an instruction executed to the start position to be used to jump to Execute the jump instruction of the patch code.

In this embodiment, the kernel can be jumped to execute the patch code by modifying the instruction, thereby implementing the program upgrade.

Optionally, the deactivation method of this embodiment may jump to the execution of the patch code to implement replacement of the code line by means of a breakpoint exception. Optionally, the embodiment may be implemented by: installing a detection point and a return point of the patch module, where the detection point is the start position, and the return point is the end position; Pointing a patch function to the probe point; at this time, the step of modifying the instruction to execute the start position to the jump instruction for executing the patch code as described above includes: The detected instruction of the probe point is modified to jump to a breakpoint instruction executing the patch code by the breakpoint exception handling function, such that when the probe point is executed, the breakpoint instruction is executed and a breakpoint exception is passed The handler jumps to execute the patch code in the patch module. Wherein, when the probe point is installed, the breakpoint exception handler is not associated with Probe the point, but associate the patch function to the probe point. The breakpoint exception handler is a public function that finds the patch function in the handler through the probe point location after entering the breakpoint exception handler through the breakpoint instruction.

In this embodiment, the probe point substantially refers to the start address of the program instruction (the corresponding instruction of the replaced code line in the binary program), and the return point substantially refers to the end address of the program instruction to be replaced. Probe points and return points are determined during the patch module creation process. In this case, the work of the above-mentioned pile agent may be to complete the setting of the detection point and the return point. After the CPU is set to the detection point, the CPU automatically enters the breakpoint exception function, and the patch code is called in the breakpoint exception function.

Optionally, the process of installing the return point includes: saving the return address after the execution of the patch code in the stack of the breakpoint exception, so that when the breakpoint exception is executed, the jump is automatically performed to the return address. The installation of the return point in the method of this embodiment is to correctly fill in the return address after the execution of the patch code in the stack of the breakpoint exception.

In this embodiment, the detected instruction of the probe point can be modified into a breakpoint instruction, so that the kernel runs a breakpoint instruction when executing to the probe point, thereby triggering the breakpoint exception processing, and jumps to execute the patch code through the breakpoint exception processing. Optionally, the patch function can be associated with the probe point. When the kernel executes the probe point, the trap operation will be executed by running the breakpoint instruction, which will cause the CPU to save the register and enter the breakpoint exception handler. The point exception handling function searches for the corresponding patch module according to the code segment address of the current CPU, and then calls the patch code in the corresponding patch module.

The deactivation setting in this embodiment may trigger the following process: the CPU will execute a breakpoint instruction to trigger a trap exception of the CPU when executing the probe point, and save the context of the current function and the CPU register as a patch module interruption point in the trap exception handling function. Process the entry parameters of the function; finally jump to execute the patch code in the patch module.

Optionally, in the method of this embodiment, the first one or more bytes of the detected instruction are replaced with a breakpoint instruction for performing the patch code by using a breakpoint exception processing manner.

As shown in FIG. 4, the process of implementing the program upgrade by applying the activation method of this embodiment will be described in detail, including the following steps:

Step 401: When installing a probe point and a return point, the stub agent first backs up the detected instruction, and then uses the CPU breakpoint instruction (such as i386 and x86_64 int3 instructions) to replace the detected instruction. The first one or a few bytes.

Before installing a probe point, you must check whether the address of the probe point is in the kernel address space or in the address space of a kernel module.

Step 402: When the CPU executes the detection point, the breakpoint abnormal operation will be executed due to the running breakpoint instruction, which will result in saving the CPU register and calling the corresponding breakpoint exception handling function.

Step 403: In the breakpoint exception processing function, the patch code registered by the probe point is called, and an entry parameter is constructed for the call of the function.

Step 404: Perform a patch code for the probe point registration.

Step 405: In order to return to the correct return point specified in the patch after the patch code registered at the probe point is processed, it is necessary to recalculate the return address of the breakpoint exception and modify the return address in the exception stack.

Specifically, the return address in the breakpoint exception stack is modified to the return address specified by the patch module, so that after the patch code is executed, it can be returned to the correct position in the patched function to continue running.

In step 406, since the single-step debugging mode is enabled, an exception of type 1 needs to be triggered after executing the probe point processing function, and returns to the patched function to continue running.

The activation method of the embodiment of the present invention can implement the replacement of the instruction in the running program by the breakpoint abnormality of the CPU and the recalculation of the return address after the breakpoint abnormality, and the replaced instruction corresponds to a code of a certain row or several lines in the source code. At the same time, the embodiment adopts a breakpoint instruction of the CPU when the instruction is replaced, and the instruction is an atomic operation, which can ensure safety and reliability when the program is upgraded online under the condition of multiple CPUs or multiple threads, and does not cause the program running state to be inconsistent. This directive is used extensively in the program debugger.

Embodiment 3:

As shown in FIG. 5, this embodiment provides an overall architecture diagram of a software online upgrade method, an ELF binary program file including debugging information, a source code file to be patched, and all required header files, and a script language translator. , ELF format parser, patch module compiler, kernel patch stub agent.

The ELF binary program file containing the debugging information may be an image file of the kernel. It can also be a binary program of the kernel module. The binary program can read all the symbol information, relocation information, and code compilation information used by the patch function, and the binary program can locate the instruction start and end addresses corresponding to the code line.

The source code file and the header file are used to create a patch script, and the source file and the header file can be used to obtain all the global variables used in the patch, the names of the local variables, and the member variables of the data structure.

The scripting language translator is used to translate the patch script into C language code, relocate the variables in the patch referenced in the patch script to an absolute address, and reference the structure member variable in the source code in the patch script. Relocate to absolute address plus member variable offset. At the same time, the scripting language translator adds the necessary locks and security checking code as needed. When the script language translator translates the script into C language, it needs to convert the function call in the script into the kernel function call, and the generated C code compiles the link to generate a loadable kernel module.

The ELF format parser is used to help the script language translator to find the symbol address in the positioning binary program and the instruction address in the binary program corresponding to the code line.

The patch module compiler refers to a binary program compilation environment included in the system, and is used to compile the patch module into a binary executable program.

The kernel patch stub agent is used to complete the management of loading, activating, deactivating, and uninstalling the patch module.

The loading of the patch module refers to loading the patch module into the kernel space and allocating corresponding system resources.

The activation of the patch module refers to the detection point and return point of the patch module. Probe points and return points are determined during the patch module creation process. The probe point essentially refers to the start address of the program instruction to be replaced, and the return point essentially refers to the end address of the program instruction to be replaced. The start address and end address of the program instruction to be replaced can be calculated by combining the code line position in the source code with the DWARF debug information in the ELF format. When the CPU executes the probe point, it will run a breakpoint instruction to trigger the trap exception of the CPU. In the trap exception handler, the context of the current function and the CPU register are used as the entry parameters of the patch module interrupt point processing function.

The deactivation of the patch module refers to restoring the original command backed up when the patch is activated to the probe point. Address, so that when the CPU executes to the probe point address, it will not run the breakpoint instruction and enter the breakpoint processing function.

The uninstallation of the patch module refers to releasing the system resources requested by the patch module and removing the patch module from the kernel space.

Embodiment 4:

As shown in FIG. 6, the embodiment provides a patch making apparatus, including: a script editing module 601, a positioning module 603, and a patch generating module 602;

The script editing module 601 is configured to write, by using a scripting language, a patch script corresponding to at least one row of the replaced code lines in the source code of the patched function, where the patch script includes the patch code corresponding to the replacement code and the replaced code is The location in the source code;

The patch generation module 602 is configured to generate, according to the patch script, a patch module that replaces the replaced code;

The positioning module 603 is configured to locate a start position and an end position of the corresponding instruction in the binary program according to the position of the replaced code in the source code, and add to the patch module.

As shown in FIG. 7, on the basis of the foregoing apparatus, the patch generation module 602 includes: a script language translator 6021 and a patch module compiler 6022; the script language translator 6021 is configured to convert the patch script into a schedule. The code of the type language is compiled into a loadable kernel module; the patch module compiler 6022 is configured to compile the kernel module into a patch module in the form of a binary program.

The device of the embodiment can use the patch to replace one or more lines of code in the function source code, thereby implementing software upgrade; since the patch is generated for the code line, the production process is simple and fast, and the patch of the invention is applied. Upgrade the software to avoid replacing the whole function for a small problem, and reduce the granularity of the repair of the program. In addition, the patch created by the method of the present invention can perform online upgrade of multiple functions in the original program without considering many The mutual calling relationship between functions; compared with related technologies, it can improve the efficiency of software upgrade, reduce the complexity of patch production, and improve the security and reliability of patch upgrade.

Embodiment 5:

As shown in Figure 8, this embodiment provides a patch activation device, including an acquisition module 801, an instruction setting module 802, and a return setting module 803;

The obtaining module 801 is configured to obtain a patch module, where the patch module includes a patch code corresponding to at least one row of the replaced code line in the source code of the patched function, and a start position of the command corresponding to the replaced code in the binary program. End position

The instruction setting module 802 is configured to set, according to the start position, a jump instruction for jumping to execute the patch code, so that when the execution to the start position is performed, the jump instruction is executed to jump to the execution location The patch code in the patch module;

The returning device module 803 is configured to: after the execution of the patch code, return to the patched function to continue running code according to the ending position.

Based on the activation device described above, the instruction setting module 802 is configured to modify an instruction executed to the start position to jump to a jump instruction to execute the patch code.

As shown in Figure 9, on the basis of the above activation device, may also include a mounting module 804;

The installation module 804 is configured to install a detection point and a return point of the patch module, where the detection point is the start position, the return point is the end position, and a patch function is installed when the probe point is installed. Associated to the probe point;

The instruction setting module 802 is configured to modify the detected instruction of the probe point to use a breakpoint exception processing function to jump to a breakpoint instruction that executes the patch code, so that when the probe point is executed, Running the breakpoint instruction and jumping to execute the patch code in the patch module by a breakpoint exception handling function.

Optionally, the instruction setting module 802 is configured to back up the detected instruction, and then replace one or more bytes in the detected instruction with a breakpoint instruction for executing a breakpoint instruction by using a breakpoint exception handling function. The breakpoint exception handling function jumps to the breakpoint instruction that executes the patch code.

The activation device of the embodiment can be configured to enable the jump instruction to jump to execute the patch code in the patch module when the kernel runs to the start position, so that one or more lines of code can be performed during the software upgrade process. replace.

The embodiment of the invention also discloses a computer program, including program instructions, when the program instruction When executed by a computer, the computer is enabled to perform any of the above-described patch making methods.

The embodiment of the invention also discloses a carrier carrying the above computer program.

The embodiment of the invention also discloses a computer program, comprising program instructions, which when executed by a computer, enable the computer to execute any of the above patch activation methods.

The above is a further detailed description of the present invention in connection with the specific embodiments, and the specific embodiments of the present invention are not limited to the description. It will be apparent to those skilled in the art that the present invention may be made without departing from the spirit and scope of the invention.

Industrial applicability

The technical solution of the present invention solves the problem that the patching of the related program upgrade is cumbersome, the repair granularity is relatively coarse, and the problem that multiple patched functions are mutually referenced cannot be well solved. Therefore, the present invention has strong industrial applicability.

Claims

A method for manufacturing a patch includes the following steps:

Writing, by using a scripting language, a patch script corresponding to at least one line of the replaced code in the source code of the patched function, where the patch script includes a patch code corresponding to the replacement code and a position of the replaced code in the source code;

Generating a patch module that replaces the replaced code according to the patch script;

Positioning the start position and the end position of the corresponding instruction in the binary program according to the position of the replaced code in the source code, and adding the start position and the end position of the corresponding instruction in the binary program to the replaced code In the patch module.
The method for manufacturing a patch according to claim 1, wherein the step of generating a patch module for replacing the replaced code according to the patch script comprises:

Converting the patch script into code of a predetermined type language and compiling it into a loadable kernel module;

The kernel module is compiled into a patch module in the form of a binary program.
The method of manufacturing a patch according to claim 2, wherein said predetermined type of language comprises a C language.
A method for activating a patch includes the following steps:

Obtaining a patch module, where the patch module includes a patch code corresponding to at least one line of the replaced code in the source code of the patched function, and a start position and an end position of the instruction corresponding to the replaced code in the binary program;

Setting a jump instruction for jumping to execute the patch code according to the start position, so that when the start position is executed, the jump instruction is executed to jump to execute the patch code in the patch module ;

According to the end position setting, after executing the patch code, returning to the patched function to continue running the code.
The method of activating a patch according to claim 4, wherein

Setting the jump instruction for jumping to execute the patch code according to the start position The steps include:

The instruction to the start position is modified to jump to the jump instruction that executes the patch code.
The method of activating a patch according to claim 5, wherein:

Before the step of acquiring the patch module, the method further includes: installing a detection point and a return point of the patch module, the detection point is the start position, and the return point is the end position; Associate the patch function to the probe point when detecting a point;

The step of modifying an instruction to execute the start position to a jump instruction for jumping to execute the patch code includes:

Modifying the detected instruction of the probe point to jump to a breakpoint instruction executing the patch code by a breakpoint exception handling function, such that when the probe point is executed, the breakpoint instruction is executed and passed The breakpoint exception handler jumps to execute the patch code in the patch module.
The method of activating a patch according to claim 6, wherein the step of modifying the detected instruction of the probe point to jump to a breakpoint instruction for executing the patch code by a breakpoint exception handling function includes :

The probed instruction is backed up, and then the first one or more bytes in the probed instruction are replaced with a breakpoint instruction for executing the patch code by a breakpoint exception handling function.
A patch making device includes: a script editing module, a positioning module, and a patch generating module, wherein

The script editing module is configured to: write, by using a scripting language, a patch script corresponding to at least one line of the replaced code in the source code of the patched function, where the patch script includes the patch code corresponding to the replaced code and the replaced code is The location in the source code;

The patch generation module is configured to: generate a patch module that replaces the replaced code according to the patch script;

The positioning module is configured to: locate a start position and an end position of the corresponding instruction in the binary program according to the position of the replaced code in the source code, and place the replaced code in the binary program corresponding to the instruction The start location and the end location are added to the patch module.
The device for creating a patch according to claim 8, wherein the patch generation module comprises: Scripting language translator and patch module compiler, where;

The scripting language translator is configured to: convert the patch script into code of a predetermined type language and compile into a loadable kernel module;

The patch module compiler is configured to: compile the kernel module into a patch module in the form of a binary program.
A patch activation device includes an acquisition module, an instruction setting module, and a return setting module, wherein

The obtaining module is configured to: acquire a patch module, where the patch module includes a patch code corresponding to at least one row of the replaced code in the source code of the patched function, and a start position and an end of the command corresponding to the replaced code in the binary program. position;

The instruction setting module is configured to: set a jump instruction for jumping to execute the patch code according to the start position, so that when the start position is executed, the jump instruction is executed to jump to execution Patch code in the patch module;

The returning device module is configured to: return to the patched function to continue running the code after executing the patch code according to the ending location setting.
The patch activation apparatus of claim 10, wherein the instruction setting module is configured to set a jump instruction for jumping to execute the patch code according to the start position as follows:

The instruction to the start position is modified to jump to the jump instruction that executes the patch code.
The patch activation device of claim 11 further comprising a mounting module, wherein:

The installation module is configured to: install a detection point and a return point of the patch module, the detection point is the start position, the return point is the end position, and when the probe point is installed, A patch function is associated with the probe point;

The instruction setting module is configured to: modify the detected instruction of the probe point to jump to a breakpoint instruction for executing the patch code by a breakpoint exception handling function, such that when the probe point is executed, Running the breakpoint instruction and jumping to execute the patch through a breakpoint exception handler The patch code in the module.
The patch activation device of claim 12, wherein the instruction setting module is configured to: back up the probed instruction, and then replace the first one or more bytes in the probed instruction with a broken The point exception handler jumps to the breakpoint instruction that executes the patch code.