Runtime Code Hooking for Print Driver and Functionality Testing

• US 20140359582A1
• Filed: 06/17/2014
• Published: 12/04/2014
• Est. Priority Date: 03/25/2008
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Needamangala, Ashwin S., Mihai, Daniel S., Ivanov, Hristo H., Popa, Marius, Fransazov, Mariyan D.
• Granted Patent: US 9,274,768 B2
• Time in Patent Office: Days
• US Class Current: 717/130
• CPC Class Codes: G06F 11/3644 by instrumenting at runtime
• CPC Class Codes: G06F 11/3668 Software testing software testing in telephone exchanges H04M3/242, testing of hardware G06F11/22
• CPC Class Codes: G06F 8/41 Compilation
• CPC Class Codes: G06F 8/656 while running

Abstract

Runtime code hooking techniques are described in which a place holder instruction within a compiled module is used as an entry point to enable code hooking. A hook function to modify a target function is developed. At runtime, the target function to be modified is located. A place holder instruction within the target function is overwritten with instructions to cause execution of the hook function when the target function is called.

Claims

1. A method comprising:

locating a target function of an application to modify on a computing device, the application compiled to inject place holder instructions as non-operative entry points into each function of the application including the target function;

identifying a hook function to execute instead of the target function when a call is made to the target function; and

overwriting a place holder instruction injected into the target function with a jump instruction to cause execution of the hook function.

2. The method as recited in claim 1, wherein:

the application is compiled to include gaps between functions in a code sequence for the application to enable insertion of instructions sufficient to jump to hook functions; and

overwriting comprises;

overwriting the place holder instruction with a jump instruction to jump to one of said gaps; and

inserting instructions sufficient to jump to the hook function in the one of said gaps.

3. The method as recited in claim 1, wherein the locating comprises calling one or more application programming interfaces (APIs) of an operating system of the computing device to receive a memory location of the target function.

4. The method as recited in claim 3, wherein the overwriting comprises calling the one or more application programming interfaces (APIs) of the operating system of the computing device to:

retrieve the target function from the memory location;

identify the place holder instruction in the target function; and

replace the place holder instruction with the jump instruction.

5. The method as recited in claim 1, wherein the place holder instruction is an initial instruction of the target function.

6. The method as recited in claim 1, wherein the place holder instruction injected into the target function has a size that is not sufficient to write a jump instruction directly to the hook function.

7. The method as recited in claim 1, wherein the hook function is configured to provide an extension to functionality of the application.

8. The method as recited in claim 1, wherein the hook function is configured to provide an update for code of the application.

9. The method as recited in claim 1, wherein the hook function is configured to test functionality of the application.

10. A method implemented by a computing device comprising:

determining a location of a target function of an application to be modified on the computing device, the application including place holder instructions injected as non-operative entry points into each function of the application including the target function and gaps maintained between functions in code for the application;

overwriting a place holder instruction of the target function with a jump instruction to jump to one of said gaps to initiate execution of a hook function instead of the target function when the target function is called; and

inserting instructions in the one of said gaps sufficient to cause execution of a hook function responsive to execution of the jump instruction to jump to the one of said gaps.

11. The method as recited in claim 10, wherein the hook function is configured to test printing functionality provided at least in part through a print subsystem of the computing device.

12. The method as recited in claim 10, further comprising calling one or more application programming interfaces (APIs) of an operating system of the computing device to determine the location of a target function in a memory of the computing device and cause the overwriting and the inserting.

13. The method as recited in claim 10, wherein the overwriting and inserting occur at runtime.

14. The method as recited in claim 10, wherein inserting instructions in the one of said gaps comprises overwriting a plurality of non-operative instructions contained in the one of said gaps with the instructions to jump to the hook function.

15. The method as recited in claim 10, wherein the place holder instruction of the target function has a size that is sufficient to write the jump instruction to the one of said gaps, but is not sufficient to write a jump instruction to the hook function.

16. A system comprising:

one or more processing devices; and

memory storing;

target code;

a hook function configured to modify functionality provided by a target function of the target code; and

one or more modules stored in the memory and executable via the one or more processing devices to;

receive information to identify the hook function and the target function of the target code to modify with the hook function, the target code including place holder instructions injected as non-operative entry points into functions of the target code including at least the target function and at least one gap maintained between functions in the target code;

overwrite a place holder instruction of the target function with a first jump instruction to jump to the at least one gap when the target function is called; and

insert another jump instruction in the at least one gap sufficient to cause a jump to execute the hook function responsive to execution of the first jump instruction.

17. The system as recited in claim 16, wherein:

the place holder instruction of the target function has a size that is insufficient to write a jump instruction to the hook function; and

the at least one gap has a size that is sufficient to write a jump instruction to the hook function.

18. The system as recited in claim 16, wherein the at least one gap includes a plurality of non-operative instructions that are overwritten to insert the another jump instruction.

19. The system as recited in claim 16, wherein the hook function is configured to bypass the target function.

20. The system as recited in claim 16, wherein the hook function is configured to include a callback to the target function to cause execution of the target function following execution of the hook function.