CN115408181A - Cross-DLL repositioning repair method and system - Google Patents

Abstract

The present invention provides a cross-DLL relocation repair method and system. The method includes: when a second DLL is loaded in the system, obtaining the repair timing of the relocation data item in the copied function code, wherein the copied function code It is the function code copied from the first DLL to the second DLL; based on the repair timing, the relocation data item in the copied function code is repaired. When loading the second DLL, the present invention uses a certain method to grab the opportunity to relocate and repair the relocation data item of the function code copied from the first DLL, and based on the captured repair timing, the cross-DLL The relocation data item is repaired, and the relocation repair of the cross-DLL relocation data item is realized.

Description

A cross-DLL relocation repair method and system

technical field

The present invention relates to the computer field, and more specifically, relates to a cross-DLL relocation repair method and system.

Background technique

For the client program, there may be multiple DLL (Dynamic Link Library, dynamic link library) components, and each DLL is an independent component function. When it is necessary to copy a function or a piece of code in a DLL to another DLL for execution, if there is relocated data in this function or this piece of code, it will cause a program crash in another dll call.

Therefore, the relocation repair needs to be performed in another DLL. In the traditional solution, the relocation repair is performed for this DLL, and there is no cross-DLL situation.

Contents of the invention

Aiming at the problem that the cross-DLL relocation cannot be realized in the prior art, the invention provides a cross-DLL relocation repair method and system.

According to the first aspect of the present invention, a cross-DLL relocation repair method is provided, including: when a second DLL is loaded in the system, obtaining a repair opportunity for the relocation data item in the copied function code, wherein, The copied function code is the function code copied from the first DLL to the second DLL; based on the repair opportunity, the relocation data item in the copied function code is repaired.

On the basis of the above technical solution, the present invention can also make the following improvements.

Optionally, when the second DLL is loaded in the system, obtaining a repair opportunity for the relocation data item in the copied function code includes: searching for all relocation data in the relocation table of the second DLL item, add a Hook point after the code segment corresponding to the last relocation data item, when the system finishes repairing all the relocation data items in the second DLL, the Hook point is triggered and perceives the copied function code Time to fix.

Optionally, adding the Hook point after the code segment corresponding to the last relocation data item includes: detecting the current operating system type and version, and querying the corresponding Hook scheme on the server according to the current operating system type and version, based on In the Hook solution, a Hook point is added after the code segment corresponding to the last relocation data item, wherein the server is configured with Hook solutions corresponding to different types and versions of the system.

Optionally, when the second DLL is loaded in the system, obtaining a repair opportunity for the relocation data item in the copied function code includes: searching for all relocation data in the relocation table of the second DLL item, set a hardware write breakpoint after the code segment corresponding to the last relocation data item, and copy the function code to the hardware write breakpoint after the system repairs all relocation data items in the second DLL , the hardware writing breakpoint is triggered, and the timing of repairing the copied function code is sensed.

Optionally, the repairing the relocation data item in the copied function code based on the repair timing includes: searching the relocation table of the first DLL according to the copied function code. All relocated data items of the copied function code; for any relocated data item, obtain the offset address of any relocated data item in the first DLL; calculate any relocated data item in the copied function code The offset address of any relocation data item; calculating the actual memory address of any relocation data item in the second DLL; based on the actual memory address of any relocation data item in the second DLL, calculating any one of the relocation data items The first default load address in the second DLL.

Optionally, the memory address where each relocation data item is stored is stored in the relocation table, and according to the copied function code, search for all the copied function codes in the relocation table of the first DLL. The relocation data item includes: for any relocation data item in the relocation table, if the memory address of any relocation data item falls between the start address and the end address of the copied function code , then any one of the relocation data items is the relocation data item of the copied function code; traverse all the relocation data items in the relocation table, and find all the relocation data of the copied function code item.

Optionally, the calculation of the offset address of any one of the relocated data items in the copied function code includes: obtaining the start address addrSrc of the first DLL loaded into the memory; obtaining the copied function code at Start address Src_Addr=addrSrc+offset1 in a DLL, wherein, offset1 is the offset address of the copied function code in the first DLL; based on the offset of any one of the relocation data items in the first DLL Shift the address VirtualAddress and the starting address of the copied function code in the first DLL, and calculate the offset address Addr1=VirtualAddress-Src_Addr of any one of the relocated data items in the copied function code.

Optionally, the calculating the actual memory address of any one of the relocation data items in the second DLL includes: obtaining the start address addrDST of the second DLL loaded into the memory;

Obtain the memory starting address Dst_Addr=addrDst+offset2 of the copied function code in the second DLL, wherein, offset2 is the offset address of the copied function code in the second DLL; based on any one of the relocation data items The offset address in the copied function code, the start address addrDST of the second DLL loaded into the memory, and the memory start address Dst_Addr of the copied function code in the second DLL, calculate any one of the relocation data items The actual memory address in the second DLL.

Optionally, the calculating the first preset loading address of any relocation data item in the second DLL based on the actual memory address of any relocation data item in the second DLL includes : Calculate the difference Diff between the initial address loaded into the memory by the first DLL and the first preset loading address; based on the actual memory address of any relocation data item in the second DLL and the difference, calculate A second preset loading address of any one of the relocation data items in the second DLL.

According to the second aspect of the present invention, a cross-DLL relocation repair system is provided, including: an acquisition module, used to obtain the repair of the relocation data item in the copied function code when the second DLL is loaded in the system Opportunity, wherein, the copied function code is the function code copied from the first DLL to the second DLL; the repair module is used to relocate data in the copied function code based on the repair opportunity item to be repaired.

According to a third aspect of the present invention, an electronic device is provided, including a memory and a processor, and the processor is configured to implement the steps of the cross-DLL relocation repair method when executing a computer management program stored in the memory.

According to a fourth aspect of the present invention, a computer-readable storage medium is provided, on which a computer management program is stored, and when the computer management program is executed by a processor, the steps of the cross-DLL relocation repair method are implemented.

A cross-DLL relocation repair method and system provided by the present invention, when loading the second DLL, use a certain method to grab the relocation data item of the function code copied from the first DLL to perform relocation repair Based on the captured repair timing, the cross-DLL relocation data item is repaired, and the relocation repair of the cross-DLL relocation data item is realized.

Description of drawings

Fig. 1 is a kind of cross-DLL relocation repair method flowchart provided by the present invention;

FIG. 2 is a schematic structural diagram of a cross-DLL relocation repair system provided by the present invention;

FIG. 3 is a schematic diagram of a hardware structure of a possible electronic device provided by the present invention;

FIG. 4 is a schematic diagram of a hardware structure of a possible computer-readable storage medium provided by the present invention.

Detailed ways

The specific implementation manners of the present invention will be further described in detail below in conjunction with the accompanying drawings and embodiments. The following examples are used to illustrate the present invention, but are not intended to limit the scope of the present invention.

Before describing the embodiment of the present invention, the DLL relocation repair technology will be described. For a DLL, it will be loaded by the program. At the same time, when it is compiled, the default starting address loaded into the memory is 0x100000. DLL There are some global variables, global functions, etc. in the . If these global variables or global functions are referenced in the code, their addresses will be added to the relocation table of the DLL, and the relocation table stores all relocation data.

Since the DLL cannot be loaded according to the preset address of 0x100000 when it is actually loaded, if the DLL is loaded according to other addresses, then all relocation data in the DLL need to be repaired, specifically, for the needs The repaired relocation data is obtained by searching the relocation table and traversing all the relocation data in the relocation table, and these relocation data are repaired in this DLL.

For a DLL, when one of the functions uses a global variable, then the code therein must have a relocation data item, and this data will be added to the relocation table of the DLL file. For a DLL, when the system loads the DLL, the system will traverse the relocation table, and then correct the data of each relocation data item.

When there are two DLLs, if the function code with relocation data in one DLL is copied to another DLL, the relocation data of this function code is not added to the other DLL at this time, resulting in this function The code is not usable in another DLL, therefore, it is necessary to solve the problem of relocation between different DLLs.

When a function code in a DLL is copied to another DLL (first name the original DLL DLLSRC, and the copied DLL is named DLLDST), at this time the relocation data items in the original DLLSRC are not deleted. Remove that relocation. At the same time, another DLLDST may not have a relocation table because it may have a relocation table. If it has a relocation table, it may not necessarily add a relocation data item, because its data may be full. And for the case where there is no relocation table, there is no way to increase the relocation data item. Therefore, it may be complicated to add a relocation data item of a new copy function in the relocation table in DLLDST, and may need to be adjusted taking into account different situations.

Since the copied function code has relocation data items, but it is not added to the relocation table in DLLDST, when loading DLLDST, the system will repair all relocation data items in the relocation table in DLLDST, but copy The relocation data items of the function code from the past will not be repaired. And if the code in DLLDST calls the copied function code before repairing the relocated data item of the copied function, a program error will result. Therefore, the repair of the relocation data item of the copied function code needs to be repaired before all functions that call it.

Referring to FIG. 1 , a flowchart of a cross-DLL relocation repair method according to an embodiment of the present invention is provided. The cross-DLL relocation repair method mainly includes the following steps:

Step S10, when the second DLL is loaded in the system, obtain a repair opportunity for the relocated data item in the copied function code, wherein the copied function code is copied from the first DLL to the second DLL function code.

In step S10, when the second DLL (DLLDST) is loaded, there is function code copied from the first DLL (DLLSRC) in the second DLL, and when the second DLL is loaded, the function code in the second DLL The relocation data items need to be repaired, and the function code copied from the first DLL (called the copied function code) also has relocation data items that need to be repaired, so when is the copied function code in the second DLL Relocating data items for repair is critical. When the second DLL is loaded in the system, a certain method is adopted to obtain the timing of repairing the relocated data item in the copied function code.

In this step, when the second DLL is loaded, the repair opportunity of relocating data in the function code copied from the first DLL is captured to realize the function of cross-DLL data repair.

Step S20: Repair the relocated data item in the copied function code based on the repair opportunity.

In the above-mentioned step S10, the repair timing of the relocation data in the function code copied from the first DLL has been obtained in the second DLL, and this step is based on the repair timing to carry out the relocation data item in the copied function code. Repair, so that the relocation data of the copied function code in the first DLL can be smoothly carried out in the second DLL.

In step S10, when loading the second DLL, a certain method is used to capture the opportunity to relocate and repair the relocation data item of the function code copied from the first DLL, and in step S20, based on the captured recovery opportunity, the The relocation data item of the DLL is repaired, and the relocation repair of the relocation data item of the cross-DLL is realized, and then the function code in the first DLL can be called in the second DLL, and the realization of the cross-DLL function function is achieved.

In the embodiment of the present invention, when the second DLL is loaded in the system in step S10, obtaining the repair opportunity for the relocation data item in the copied function code includes: searching for all the relocation data items in the second DLL relocation table Relocate data items, add a Hook point after the code segment corresponding to the last relocation data item, when the system repairs all the relocation data items in the second DLL, the Hook point is triggered, and the The repair timing of the copied function code.

It is understandable that when the second DLL is loaded, because there are function codes copied from the first DLL in the second DLL, the second DLL itself has relocation data items, which are copied from the first DLL. There are also relocation data items in the function code copied from the DLL. Therefore, how to repair the relocation data items in the two DLLs in an orderly manner is very important, so when should the relocation data items in the first DLL be repaired? It is related to whether the program can be loaded normally.

Specifically, in the process of grasping the opportunity to relocate and repair the relocation data item of the function code copied from the first DLL, the function loadlibrary of the system loaded DLL can be hooked to perceive the system to repair and relocate timing. The hook point can be placed after the system loads the second DLL into the memory, and after the relocation data items of the second DLL are repaired. Then the Hook function will perform Hook at this point. When the system loads the second DLL, it will repair and relocate all the relocation data items of this DLL. Fix the relocation data item of the copy function code in the function logic.

In this step, the Hook point is added after the code segment corresponding to the last relocation data item in the second DLL. When the system finishes repairing all the relocation data items in the second DLL, the Hook point is triggered. At this time To repair the relocation data item in the first DLL, so that after the second DLL is loaded, the repair of the relocation data item in the second DLL and the first DLL is successfully completed, so that the second DLL can be loaded smoothly .

In a possible embodiment, adding a Hook point after the code segment corresponding to the last relocation data item in the above steps includes: detecting the current operating system type and version, according to the current operating system type and version, on the server Query the corresponding Hook scheme above, based on the Hook scheme, add a Hook point after the code segment corresponding to the last relocation data item, wherein, the server is configured with Hook schemes corresponding to different types and different versions of the operating system.

It is understandable that when using the Hook function to capture the repair timing of the relocated data item of the copied function code, it is perceived by Hooking the system function Loadlibrary, then the Hook can accurately perceive the second DLL All relocated data items are fixed. However, when hooking the system function Loadlibrary, you need to consider the actual situation. The actual situation is that different operating systems have some differences in the internal implementation of the Loadlibrary function. These differences need to be taken into account, and there will also be new releases in the future The system needs to adapt to the new system, so its hooks are closely related to the version of the operating system, and all hooks need to take the system version into account.

Based on this, this step detects the type and version of the current operating system when the system loads the second DLL, and queries the corresponding Hook scheme from the server according to the type and version of the current operating system. Based on the Hook scheme, the last relocation data Add the Hook point after the code segment corresponding to the item. Wherein, corresponding Hook solutions are configured on the server for different operating systems and operating systems of different versions.

In a possible embodiment, when the second DLL is loaded in the system in step S10, obtaining the repair opportunity for the relocation data item in the copied function code includes: in the relocation table of the second DLL Find all the relocation data items, set the hardware write breakpoint after the code segment corresponding to the last relocation data item, and write the breakpoint to the hardware after the system repairs all the relocation data items in the second DLL When the function code is copied, the hardware writing breakpoint is triggered, and the repair opportunity of the copied function code is sensed.

It can be understood that, in step S10, when the second DLL is loaded in the system, the ways to obtain the timing of repairing the relocated data item in the copied function code may include multiple methods, wherein the above steps are in the second Find all relocation data items in the relocation table of a DLL, and add a Hook point after the code segment corresponding to the last relocation data item, but the actual situation needs to be taken into account when hooking the system function Loadlibrary, which is different For the system, there will be some differences in the internal implementation of the Loadlibrary function. These differences need to be taken into account. At the same time, there will be a new system that will be released in the future and it will need to be adapted to the new system. Therefore, its hook is closely related to the version of the operating system. Related, all hooks need to take into account the system version, and different hook solutions need to be configured based on different versions of the operating system, which will be cumbersome.

Therefore, in this step, the recovery opportunity of the copied function code can be obtained by setting a hardware writing breakpoint. For all the relocation data items of the second DLL, the repair of the last relocation data item indicates that the repair and relocation function of the DLL is over. By setting a hardware write breakpoint to the code, when the system writes data to it, the hardware write breakpoint will be triggered, then this timing point will repair the relocation data item of the copied function code, In this way, it is ensured that the timing of the relocation repair is just right, neither ahead of schedule nor behind, thus ensuring the correctness of the relocation repair function as much as possible.

Specifically, search for all relocation data items in the relocation table of the second DLL, find the last relocation data item, and find the code segment corresponding to the last relocation data item, and set the hardware at the code segment Write breakpoints. When the system finishes repairing all the relocation data items in the second DLL, the hardware writing breakpoint is triggered, and at this moment, the relocation data items of the copied function code can be repaired.

Among them, the specific implementation of setting the hardware write breakpoint is to register an exception by calling the API function AddVectoredExceptionHandler, the function PVOID WINAPIAddVectoredExceptionHandler(

ULONG FirstHandler,

PVECTORED_EXCEPTION_HANDLERVectoredHandler);

Among them, FirstHandler is filled with 0, indicating that the registered exception handling function is the optimal one to take over the exception after the repair of the relocation data item is completed.

Wherein, since the system repair relocation may be executed in any thread of the process, it is necessary to set hardware write breakpoints for all threads, and the thread handle can be obtained by traversing all threads. The method of setting a hardware write breakpoint in each thread is, for each thread, first obtain the context information of the thread by calling the API function GetThreadContext, where the call to the function GetThreadContext passes in the parameter CONTEXT_DEBUG_REGISTERS to obtain the register information of the thread context , The four registers of the CPU hardware breakpoint are Dr0, Dr1, Dr2 and Dr3 respectively.

If the embodiment of the present invention chooses to set memory read and write access to Dr0, then it is necessary to set ctx.Dr0=Reloc_Address, where Reloc_Address is the memory address of the relocation data item that needs to be set. ctx.Dr7|＝0xd0501, this value means only monitor the written breakpoint. After setting the value of the register, set the value of the register to the context of the thread by calling the API function SetThreadContext. Once this function is called, the monitoring of the access of the set memory address begins. When the hardware write breakpoint is triggered, the previously written setting exception handling function AddVectoredExceptionHandler will be called to register the exception handling function.

Therefore, you can write an exception handling function void Handler() {when an exception occurs, this function will be called. At this time, the function of system repair and relocation is perceived, so the copied function can be repaired here. The relocation data item for the code. }

In this step, the method of setting the hardware write breakpoint is used to obtain the repair timing of the copied function code. Regardless of the difference in the operating system, the setting of the hardware write breakpoint can be realized, and then the repair of the copied function code can be accurately captured. Timing Fix timing on second DLL load.

In step S20, based on the repair opportunity, the relocation data item in the copied function code is repaired, including:

Step S201 , according to the copied function code, search all relocation data items of the copied function code in the relocation table of the first DLL.

It can be understood that the above-mentioned embodiments have introduced two kinds of repair opportunities for grabbing the relocation data item of the copied function code. When the repair opportunity arrives, the function code copied from the first DLL in the second DLL will Locate data items for repair.

In step S201, since the relocation item table of the second DLL (DLLDST) does not store the relocation data item in the first DLL, it is necessary to go to the relocation table of the original DLLSRC to find the relocation item data , query which relocation data items are in the copy function code in the relocation table of the original first DLL. The specific query is by traversing the relocation table of the first DLL, which stores the memory addresses of the relocation data items of all function codes. Based on the memory address of each relocated data item, it is judged whether it falls within the address range between the start address and the end address of the copied function code. If it falls, it means that the relocated data item belongs to the copied function code. A data item is relocated, otherwise it is not. Finally, after traversing all relocation data items, all relocation data items of the copied function code can be obtained.

Step S202. For any relocation data item, obtain the offset address of any relocation data item in the first DLL; calculate the offset address of any relocation data item in the copied function code.

In step S202, when calculating the offset address of any relocated data item in the copied function code, obtain the start address addrSrc of the first DLL loaded into the memory; obtain the copied function code in the first DLL The starting address of Src_Addr=addrSrc+offset1, wherein, offset1 is the offset address of the copied function code in the first DLL; based on the offset address VirtualAddress of any relocation data item in the first DLL and the copied For the starting address of the function code in the first DLL, calculate the offset address Addr1=VirtualAddress-Src_Addr of any one of the relocated data items in the copied function code.

Step S203, calculating the actual memory address of any relocation data item in the second DLL.

In step S203, the actual memory address of any relocation data item in the second DLL is calculated, including: obtaining the start address addrDST of the second DLL loaded into the memory; obtaining the copied function code in the second DLL The memory starting address Dst_Addr=addrDst+offset2, wherein, offset2 is the offset address of the copied function code in the second DLL; based on the offset address of any relocation data item in the copied function code, the second The first DLL is loaded into the memory start address addrDST and the memory start address Dst_Addr of the copied function code in the second DLL, and the actual memory address of any one relocation data item in the second DLL is calculated.

Step S204. Based on the actual memory address of any relocated data item in the second DLL, calculate a first preset loading address of any relocated data item in the second DLL.

In step S204, the difference Diff between the initial address loaded into the memory by the first DLL and the first preset loading address is calculated; based on the actual memory address of any one of the relocation data items in the second DLL and The difference is used to calculate a second preset loading address of any relocation data item in the second DLL.

Based on the second preset loading address of any relocation data item calculated in step S204 in the second DLL, each relocation data item of the copy function code is repaired, and the repair mainly includes the following steps:

(1) Obtain the starting address of loading DLLSRC into memory.

DWORD addrSrc=GetModuleHandle("DLLSRC"); by passing the name of DLLSRC to the system function GetModuleHandle, the starting address of DLLSRC can be obtained.

(2) Obtain the start address of the copied function code in DLLSRC.

It is necessary to obtain the start address of the function code copied to DLLDST in DLLSRC to facilitate subsequent calculation of relocated data, and use the Src_Addr variable to represent its start address. The acquisition method can be obtained by checking the offset address of the copied function code in DLLSRC, and then adding the starting address loaded by DLLSRC to obtain the actual starting address of the copied function code in memory. The calculation formula is: Src_Addr＝addrSrc+ offset1, offset1 is the offset address of the copied function code in DLLSRC.

(3) Obtain the starting address of loading DLLDST into the memory.

DWORD addrDst=GetModuleHandle("DLLDST"); by passing the name of DLLDST to the system function GetModuleHandle, the starting address of DLLDST can be obtained.

(4) Obtain the memory start address of the copy function code in DLLDST.

Since the copied function code is copied from DLLSRC to DLLDST, the memory start address copied to DLLDST can be recorded when copying. Specifically, it may be that a code segment is added in DLLDST, then the function can be copied to the starting address of this code segment. Obtaining the start address of this newly added code segment in DLLDST obtains the address of the copy function code. Then set a variable Dst_Addr=addrDst+offset2, wherein, Dst_Addr is the memory start address of the copy function code in DLLDST, addrDst is the start address of DLLDST loaded into the memory, and offset2 is the offset address in the copied function code DLLDST.

(5) Calculation of the specific relocation of each relocation data item:

First, it is necessary to calculate the difference between the actual address of DLLSRC loaded into memory and the preset loading address originally set at compile time. Among them, the default loading address of DLLSRC can be parsed from the format header of DLLSRC, then this field can be the value OptionalHeader.ImageBase, and this value is the default loading address of the module.

Diff = addrSrc-OptionalHeader.ImageBase;

Among them, addrSrc is the starting address of DLLSRC actually loaded into the memory. By subtracting the two values, we can get the relative difference Diff.

This difference is the difference that needs to be corrected for each relocation data item in the copied function code. At the same time, the relocation data item of the copied function code represents the global variable or global function in the DLLSRC used by it, so the relocation The repair of data items also needs to be repaired according to the use of global variables in DLLSRC, and the result of the repair is that although the copy function code is in DLLDST, the global variables or global functions inside the function are still called in DLLSRC.

The repair calculation for each relocation data item is as follows: VirtualAddress indicates the offset address of the relocation data item relative to the DLL, which is the offset address of the relocation data item relative to DLLSRC, and this function has been copied to DLLDST Therefore, it is necessary to calculate the position of the relocation data item in DLLDST.

The specific calculation formula is as follows, calculate the offset address of any relocated data item in the copied function Addr1=VirtualAddress-Src_Addr, calculate Addr1, and then calculate the actual address of the relocated data item in DLLDST Addr2=Addr1+addrDST+Dst_Addr , where addrDST represents the actual starting address of DLLDST loaded into the memory, and Dst_Addr is the offset address of the copied function code in DLLDST.

Since there is a certain difference between the actual loading address and the default loading address, the default loading address of the relocation data item in DLLDST is *Addr2=Addr2+Diff, and the relocation repair address of the final relocation data item is obtained.

For all the relocation data items in the copied function code, the above-mentioned method is used to calculate the addresses repaired in DLLDST, so that all relocation data items in the copied function code can be repaired, and all the relocation data items in the copied function code are realized. Relocation fixes for relocated data items.

The embodiment of the present invention provides a cross-DLL relocation repair method. When the second DLL is loaded, a certain method is used to capture the relocation data item of the function code copied from the first DLL to perform relocation repair. Based on the captured repair timing, the cross-DLL relocation data item is repaired, and the relocation repair of the cross-DLL relocation data item is realized.

When the second DLL is loaded in the system, when obtaining the repair opportunity of the relocation data item of the copied function code, two different methods for obtaining the repair opportunity are provided, wherein, respectively, using the code of the second DLL to add Hook points to grab the repair timing of the relocated data item in the copied function code, and set the hardware write breakpoint at the code where the last relocated data item is located in the second DLL, and write the breakpoint through the hardware To obtain the repair opportunity of the relocated data item in the copied function code, a corresponding method can be used to capture the repair opportunity according to the existing situation.

FIG. 2 is a structural diagram of a cross-DLL relocation repair system provided by an embodiment of the present invention. As shown in FIG. 2 , a cross-DLL relocation repair system includes an acquisition module 201 and a repair module 202, wherein:

The obtaining module 201 is used to obtain the repair opportunity of the relocated data item in the copied function code when the second DLL is loaded in the system, wherein the copied function code is copied from the first DLL to the second DLL Function codes in the two DLLs;

The repair module 202 is configured to repair the relocated data item in the copied function code based on the repair opportunity.

It can be understood that the cross-DLL relocation repair system provided by the present invention corresponds to the cross-DLL relocation repair method provided in the foregoing embodiments, and the related technical features of the cross-DLL relocation repair system can refer to the cross-DLL The relevant technical features of the relocation repair method will not be repeated here.

Please refer to FIG. 3 . FIG. 3 is a schematic diagram of an embodiment of an electronic device provided by an embodiment of the present invention. As shown in Figure 3, the embodiment of the present invention provides an electronic device, including a memory 310, a processor 320, and a computer program 311 stored in the memory 310 and operable on the processor 320, and the processor 320 executes the computer program 1311 When the second DLL is loaded in the system, obtain the opportunity to repair the relocated data item in the copied function code, wherein the copied function code is copied from the first DLL to the second DLL The function code in the function code; based on the repair opportunity, repair the relocation data item in the copied function code.

Please refer to FIG. 4 , which is a schematic diagram of an embodiment of a computer-readable storage medium provided by the present invention. As shown in FIG. 4 , the present embodiment provides a computer-readable storage medium 400 on which a computer program 411 is stored. When the computer program 411 is executed by the processor, the following steps are implemented: when the second DLL is loaded in the system , obtain the repair opportunity of the relocated data item in the copied function code, wherein the copied function code is the function code copied from the first DLL to the second DLL; based on the repair opportunity, the Relocating data items in the copied function code is repaired.

It should be noted that, in the foregoing embodiments, descriptions of each embodiment have their own emphases, and for parts that are not described in detail in a certain embodiment, reference may be made to relevant descriptions of other embodiments.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems, or computer program products. Accordingly, the present invention can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded computer, or other programmable data processing device to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing device produce a machine for A device for realizing the functions specified in one or more procedures of a flowchart and/or one or more blocks of a block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

While preferred embodiments of the invention have been described, additional changes and modifications to these embodiments can be made by those skilled in the art once the basic inventive concept is understood. Therefore, it is intended that the appended claims be construed to cover the preferred embodiment as well as all changes and modifications which fall within the scope of the invention.

Obviously, those skilled in the art can make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. Thus, if these modifications and variations of the present invention fall within the scope of the claims of the present invention and equivalent technologies thereof, the present invention also intends to include these modifications and variations.

Claims (10)

1. A method for relocation repair across DLLs, comprising:

when a second DLL is loaded in the system, acquiring a repair opportunity for relocating data items in copied function codes, wherein the copied function codes are function codes which are copied from the first DLL to the second DLL;

and repairing the relocated data item in the copied function code based on the repair opportunity.

2. The relocation repair method according to claim 1, wherein said obtaining a repair time for the relocated data item in the copied function code when loading the second DLL in the system, comprises:

and searching all relocation data items in a relocation table of a second DLL, adding a Hook point after a code segment corresponding to the last relocation data item, and when the system finishes repairing all the relocation data items in the second DLL, triggering the Hook point and sensing the repair time of the copied function code.

3. The relocation repair method according to claim 2, wherein said adding a Hook point after the code section corresponding to the last relocation data item comprises:

detecting the type and the version of a current operating system, inquiring a corresponding Hook scheme on a server according to the type and the version of the current operating system, and adding a Hook point after a code segment corresponding to a last relocation data item based on the Hook scheme, wherein the server is configured with Hook schemes corresponding to systems of different types and different versions.

4. The relocation repair method according to claim 1, wherein said obtaining a repair opportunity for the relocated data item in the copied function code when loading a second DLL in the system, comprises:

searching all the relocation data items in the relocation table of the second DLL, setting a hardware writing breakpoint after a code segment corresponding to the last relocation data item, and triggering the hardware writing breakpoint to sense the repair time of the copied function code when the system copies the function code at the hardware writing breakpoint after repairing all the relocation data items in the second DLL.

5. The relocation repair method according to any one of claims 1 to 4, wherein the repairing the relocated data item in the copied function code based on the repair opportunity comprises:

according to the copied function code, all relocation data items of the copied function code are searched in a relocation table of a first DLL;

for any relocation data item, obtaining an offset address of the any relocation data item in a first DLL;

calculating an offset address of the any relocation data item in the copied function code;

calculating the actual memory address of any relocation data item in the second DLL;

and calculating a first preset load address of any relocation data item in the second DLL based on the actual memory address of any relocation data item in the second DLL.

6. The relocation repair method according to claim 5, wherein the relocation table stores the memory address of each relocation data item, and the searching all relocation data items of the copied function code in the relocation table of the first DLL according to the copied function code comprises:

for any relocation data item in the relocation table, if the memory address of any relocation data item falls between the start address and the end address of the copied function code, the any relocation data item is the relocation data item of the copied function code;

and traversing all the relocation data items in the relocation table to find all the relocation data items of the copied function code.

7. The relocation repair method according to claim 5, wherein said calculating an offset address of said any one of the relocation data items in the copied function code comprises:

acquiring an initial address addrSrc loaded into a memory by a first DLL;

acquiring a starting address Src _ Addr = addrSrc + offset1 of the copied function code in the first DLL, wherein the offset1 is an offset address of the copied function code in the first DLL;

and calculating the offset address Address 1= VirtualAddress-Src _ Address of any relocation data item in the copied function code based on the offset address VirtualAddress of any relocation data item in the first DLL and the starting address of the copied function code in the first DLL.

8. The relocation repair method according to claim 7, wherein said calculating the actual memory address of said any one of the relocation data items in the second DLL comprises:

acquiring an initial address addrDST loaded to a memory by a second DLL;

obtaining a memory start address Dst _ Addr = addrDst + offset2 of the copied function code in the second DLL, wherein the offset2 is an offset address of the copied function code in the second DLL;

and calculating the actual memory address of any relocation data item in the second DLL based on the offset address of any relocation data item in the copied function code, the starting address addrDST loaded to the memory by the second DLL and the memory starting address Dst _ Addr of the copied function code in the second DLL.

9. The relocation repair method according to claim 8, wherein said calculating a first preset load address of any one of the relocation data items in a second DLL based on an actual memory address of the any one of the relocation data items in the second DLL comprises:

calculating a difference value Diff between an initial address loaded into a memory by a first DLL and a first preset loading address;

and calculating a second preset load address of any relocation data item in the second DLL based on the actual memory address of any relocation data item in the second DLL and the difference value.

10. A relocation repair system across DLLs, comprising:

the system comprises an acquisition module, a restoration module and a restoration module, wherein the acquisition module is used for acquiring the restoration opportunity of the relocated data item in the copied function code when a second DLL is loaded in the system, and the copied function code is the function code copied from the first DLL to the second DLL;

and the repairing module is used for repairing the relocated data item in the copied function code based on the repairing opportunity.

Images