Multi-process fuzz testing method, device and computer equipment based on QEMU

By judging the category of the executed program in AFL-QEMU and adding the QEMU program path, the problems of multi-process fuzz testing and script file processing are solved, and effective testing of multi-process and script files are realized, improving the effect of fuzz testing and efficiency.

CN117785719BActive Publication Date: 2024-11-08北京水木羽林科技有限公司
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202410032925.8
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2023-10-30
Filing Date
2024-01-09
Publication Date
2024-11-08
Estimated Expiration
2044-01-09

AI Technical Summary

Technical Problem

The design of AFL-QEMU cannot obtain the coverage information of child processes in multi-process situations, and cannot correctly parse and execute executable files of script type.

Method used

By judging the category of the executed program when it starts a new process, parsing the script header or parameter list of the ELF file of the script file, adding the QEMU program path, and using the execve function to enable the operating system to start a new process, so that the QEMU program can obtain the new process's The coverage was fuzzy.

Benefits of technology

Fuzz testing of multiple processes is implemented, testing effect and efficiency is improved, the application scope of QEMU programs is expanded, and more types of executable files and script files are handled.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN117785719B_ABST
    Figure CN117785719B_ABST
Patent Text Reader

Abstract

The present application discloses a multi-process fuzz testing method, device and computer equipment based on QEMU. The method includes: when the executed program starts a new process, if the executed program is a script file, extract the parameter list required to start the script interpreter from the script header of the executed program; if the executed program is an ELF file, determine whether the executed program is an executable program of the current operating system, and if so, extract the parameter list from the executed program; add the path of the QEMU program before the obtained parameter list, and hand over the parameter list with the path of the QEMU program to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and perform fuzz testing on the new process through the QEMU program. Through the present application, the QEMU program is still used to start the new process when starting the new process, so that the child process can also obtain the coverage, and fuzz testing can be performed on multiple processes.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present application relates to the field of fuzz testing technology, and in particular to a multi-process fuzz testing method, apparatus, computer device and storage medium. Background Art

[0002] Fuzz testing is a widely used software security auditing technique that attempts to trigger potential errors or vulnerabilities in the target software by providing a large amount of disordered input. An important tool in fuzz testing is AFL (American FuzzyLop), which is a software security testing tool based on fuzz testing. It discovers potential vulnerabilities and errors by generating a large amount of input data and observing the behavior of the target program; it uses compile-time instrumentation and genetic algorithms to perform fuzz testing efficiently. AFL has discovered a large number of security vulnerabilities for many software projects.

[0003] A major limitation of AFL is that it requires the use of a special compiler (afl-cc) for compile-time instrumentation, which can inject additional code into the target software to collect information about the program execution path and input data at runtime, thereby achieving the purpose of fuzz testing. However, in some cases, instrumentation using afl-cc is not possible, such as for binary executables, target software that cannot be recompiled, or the software to be tested comes from an untrusted third party.

[0004] To solve this problem, AFL proposed the afl-qemu mode, which can perform fuzz testing on uninstrumented binaries. afl-qemu is an extension of AFL that uses the dynamic binary translation function of the QEMU emulator to perform instrumentation, so that any binary executable file can be fuzz tested without the need for source code or recompilation. This greatly expands the scope of fuzz testing, making any binary executable program a target for fuzz testing.

[0005] However, the inventors realize that the design of afl-qemu does not take into account the situation of multiple processes. In some software tests, the target program may start new processes to perform tasks, and the behavior of these sub-processes may also affect the security of the software. In this case, the original design of afl-qemu cannot obtain the coverage information of the sub-processes, and therefore cannot perform effective fuzz testing on the behavior of the sub-processes.

[0006] In addition, considering that in modern operating system environments, executable files are not necessarily written directly in machine code, but may also be script files, such as Python, Shell, etc., which rely on corresponding interpreters to execute. In this case, directly using QEMU to fuzz test the script file will encounter problems because QEMU cannot correctly parse and execute the code in the script file.

[0007] In summary, although afl-qemu expands the scope of fuzz testing, it still has obvious defects and deficiencies when handling multi-process fuzz testing and script-type executable files. Summary of the invention

[0008] The present application provides a QEMU-based multi-process fuzz testing method, apparatus, computer equipment and storage medium, aiming to solve the technical problem that the original design of afl-qemu cannot obtain the coverage information of the sub-process.

[0009] In a first aspect, a multi-process fuzz testing method based on QEMU includes:

[0010] S1, when the executed program starts a new process, determining the type of the executed program;

[0011] S2, if it is determined that the executed program is a script file, parsing the script header of the executed program, and extracting a parameter list required to start a script interpreter from the script header of the executed program;

[0012] If it is determined that the executed program is an ELF file, determining whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, extracting a parameter list from the executed program;

[0013] S3, adding the path of the QEMU program before the obtained parameter list, and handing over the parameter list with the path of the QEMU program added to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and performing fuzz testing on the new process through the QEMU program.

[0014] Optionally, if the executed program is a file beginning with an ASCII character #!, it is determined that the executed program is a script file; otherwise, it is determined that the executed program is an ELF file.

[0015] Optionally, the determining whether the executed program is an executable program of the current operating system includes:

[0016] Obtaining header information of the executed program, and extracting an identifier of the target operating system from the header information;

[0017] Determine whether the identifier of the target operating system matches the current operating system; if they match, determine that the executed program is an executable program of the current operating system.

[0018] Optionally, step S2 further includes:

[0019] When parsing the script header of the executed program, if the script header of the executed program is illegal, output an error warning prompt;

[0020] When determining whether the executed program is an executable program of the current operating system, if it is determined that the executed program is not an executable program of the current operating system, an error warning prompt is output.

[0021] Optionally, in step S3, the current operating system calls the execve function to enable the current operating system to start a new process using the QEMU program.

[0022] In a second aspect, a multi-process fuzz testing device based on QEMU comprises:

[0023] A category determination module, used to determine the category of the executed program when the executed program starts a new process;

[0024] A parameter list extraction module is used to parse the script header of the executed program if it is determined that the executed program is a script file, and extract the parameter list required to start the script interpreter from the script header of the executed program;

[0025] If it is determined that the executed program is an ELF file, determining whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, extracting a parameter list from the executed program;

[0026] The path adding module is used to add the path of the QEMU program before the obtained parameter list, and pass the parameter list of the added path of the QEMU program to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; the new process is fuzz tested through the QEMU program.

[0027] According to a third aspect, a computer device comprises a memory and a processor, wherein the memory stores a computer program, and the processor implements the steps of any one of the methods according to the first aspect when executing the computer program.

[0028] In a fourth aspect, a computer-readable storage medium stores a computer program, wherein the computer program, when executed by a processor, implements the steps of any one of the methods described in the first aspect.

[0029] Compared with the prior art, this application has at least the following beneficial effects:

[0030] The embodiment of the present application provides a multi-process fuzz testing method based on QEMU. When the executed program starts a new process, the category of the executed program is judged. If the executed program is a script file, the parameter list required for starting the script interpreter is extracted from the script header of the executed program; if the executed program is an ELF file, it is judged whether the executed program is an executable program of the current operating system. If so, the parameter list is extracted from the executed program; the path of the QEMU program is added before the obtained parameter list, and the parameter list with the added path of the QEMU program is handed over to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; the new process is fuzz tested by the QEMU program; the startup mode of the QEMU program is changed, so that when starting a new process, the QEMU program is still used to start, so that the child process can also obtain coverage, and then the multiple processes can be fuzz tested, thereby improving the effect and efficiency of the fuzz test; at the same time, by correctly processing various types of executable files and script files, the application scope of the QEMU program is wider, and more types of test scenarios can be handled. BRIEF DESCRIPTION OF THE DRAWINGS

[0031] Figure 1 A flowchart of a multi-process fuzz testing method based on QEMU is provided for one embodiment of the present application;

[0032] Figure 2 Another flowchart of a QEMU-based multi-process fuzz testing method provided by an embodiment of the present application;

[0033] Figure 3 A module architecture block diagram of a QEMU-based multi-process fuzzy testing device provided in one embodiment of the present application;

[0034] Figure 4 An internal structure diagram of a computer device provided for one embodiment of the present application. DETAILED DESCRIPTION

[0035] In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0036] In the description of the present application: unless otherwise specified, expressions such as “include”, “comprising”, “having”, etc. also mean “not limited to” (certain units, components, materials, steps, etc.).

[0037] In one embodiment, Figure 1 As shown, a multi-process fuzz testing method based on QEMU is provided, comprising the following steps:

[0038] S1, when the executed program starts a new process, determine the type of the executed program.

[0039] The executed program refers to the target program to be fuzz tested, that is, the program to be tested.

[0040] S2, if it is determined that the executed program is a script file, the script header of the executed program is parsed, and a parameter list required to start the script interpreter is extracted from the script header of the executed program;

[0041] If it is determined that the executed program is an ELF file, it is determined whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, a parameter list is extracted from the executed program.

[0042] Specifically, if the executed program is a file beginning with the ASCII character #!, it is determined that the executed program is a script file; otherwise, it is determined that the executed program is an ELF file.

[0043] Among them, extracting the parameter list required to start the script interpreter from the script header of the executed program usually needs to follow the format and protocol of the script file; according to the format and standard of the script file, the script header can be parsed and the parameter list required to start the script interpreter can be extracted. For example, the script header is first split into multiple strings by spaces, and then the first string (i.e., the interpreter path) is assigned to the interpreter variable by deconstruction assignment, and the remaining strings (i.e., the parameter list) are assigned to the args list variable, so that the parameter list required to start the script interpreter can be easily obtained.

[0044] In addition, ELF (Executable and Linkable Format) is an executable file format, which is widely used in Unix and Unix-like operating systems. ELF files are composed of 4 parts, namely ELF header, program header table, section and section header table.

[0045] In an ELF file, the parameter list usually refers to the command line parameters of the program, that is, the parameter information passed to the program through the command line. These parameters can include program options, parameter values, file names, etc. In an ELF file, the parameter list is usually stored in a specific section in the form of a string, such as ".rodata" (read-only data segment) or ".data" (data segment). These strings represent the command line parameters of the program, and each parameter is separated by a space or other separator. Getting the parameter list of an ELF file means parsing the corresponding section, reading the string stored in it, and parsing it into the actual command line parameters.

[0046] Specifically, parsing the parameter list of the ELF file can be done by following the steps below:

[0047] 1. Open the ELF file and read the corresponding section (such as ".rodata" or ".data").

[0048] 2. Read the stored strings from the selected section, which represent the command line arguments of the program.

[0049] 3. Parse the string into actual command line parameters based on the agreed delimiters (such as spaces).

[0050] 4. Save the parsed command line parameters in a parameter list for use and processing by the program at runtime.

[0051] Furthermore, determining whether the executed program is a program of the current operating system and the current architecture includes:

[0052] Obtain the header information of the executed program and extract the identifier of the target operating system from the header information;

[0053] Determine whether the identifier of the target operating system matches the current operating system; if they match, determine that the executed program is an executable program of the current operating system.

[0054] Furthermore, step S2 further includes:

[0055] When parsing the script header of the executed program, if the script header of the executed program is illegal, an error warning prompt is output;

[0056] When determining whether the executed program is an executable program of the current operating system, if it is determined that the executed program is not an executable program of the current operating system, an error warning prompt is output.

[0057] Specifically, the operating system refers to the operating system currently running on the system, such as Windows, Linux, macOS, etc.; judging whether a program is for this operating system is to judge whether the program is applicable to the currently running operating system. The architecture refers to the CPU architecture used by the current system, such as x86, ARM, MIPS, etc.; judging whether a program is for this architecture is to judge whether the program is applicable to the CPU architecture used by the current system.

[0058] Different operating systems and CPU architectures have different binary file formats and instruction sets, so the executable file of the same program may perform differently on different operating systems or CPU architectures. In order to ensure that the program can run normally, it needs to be compiled and optimized for different operating systems and CPU architectures. Therefore, when performing fuzz testing, it is necessary to determine whether the program being tested is applicable to the current operating system and CPU architecture to avoid errors or unpredictable results.

[0059] Therefore, judging whether the executed program is a program of this operating system and this architecture is to ensure that afl-qemu will only run in a suitable environment, avoiding errors or unpredictable results caused by executing programs on incompatible operating systems or architectures.

[0060] Specifically, for ELF files, its target operating system and architecture can be determined by checking the header information of the ELF file. The header of the ELF file contains basic information about the file, including identifiers of the target operating system and architecture. By comparing these identifiers and matching them with the operating system and architecture identifiers of the current system, it is possible to determine whether the ELF file is a program for this operating system and this architecture.

[0061] If the result is a match, the subsequent fuzz testing process will continue; if the result is a mismatch, an error will be reported and the user will be prompted that the program is not applicable to the current operating system or architecture. This judgment mechanism can ensure that afl-qemu will only run in a suitable environment, improving the reliability and stability of the program.

[0062] S3, adding the path of the QEMU program before the obtained parameter list, and handing over the parameter list with the path of the QEMU program added to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and performing fuzz testing on the new process through the QEMU program.

[0063] The current operating system calls the execve function to enable the current operating system to start a new process using the QEMU program.

[0064] The purpose of calling the execve function is to replace the current process with a new executable program. The execve function is a system call used to execute a new executable program in the context of the current process. It accepts two parameters: the first parameter is the path of the new program, and the second parameter is a string array for the command line parameters passed to the new program.

[0065] When the execve function is called, the operating system loads the executable file at the specified path, replaces the code and data segments of the current process with it, and then starts executing the entry point of the new program. This means that the code, data, and state of the original process will be completely replaced, and the new program will be executed from the beginning.

[0066] Specifically, adding the path of the QEMU program before the obtained parameter list, and handing the parameter list after adding the QEMU program path to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, may include the following steps:

[0067] 1. Get the path of the QEMU program: First, you need to determine the path of the QEMU program in the system. You can get the QEMU executable file path through the configuration file, environment variables, or by directly specifying the path.

[0068] 2. Build a new parameter list: Combine the obtained QEMU path with the original parameter list to build a new parameter list. This new parameter list will be used as a parameter of the execve function to start a new process.

[0069] 3. Call the execve function: Use the execve function provided by the operating system and pass the new parameter list to the function. The execve function will load the QEMU executable file and replace the code and data segments of the current process with it. At the same time, pass the new parameter list to QEMU so that QEMU uses these parameters when starting a new process.

[0070] 4. The operating system starts a new process: After calling the execve function, the operating system will load the QEMU executable file according to the passed parameter list and start a new process. The new process will use QEMU as the execution environment to execute the program under test.

[0071] Another flowchart of the multi-process fuzz testing method based on QEMU provided in this application can be found in Figure 2 In other words, the method proposed in this application includes the following steps:

[0072] When afl-qemu starts a new process, it determines the executed program

[0073] 1. If the file starts with the ASCII character #!, it is considered a script;

[0074] a. Process its script header (shebang) and split it into a list of parameters required to start the script interpreter

[0075] b. If the script header is illegal, report an error and exit

[0076] 2. Otherwise, if it is an ELF file, determine whether it is a program for this operating system and this architecture;

[0077] a. If yes, continue

[0078] b. If not, report an error and exit

[0079] 3. Add the path of the qemu program before the obtained parameter list so that the operating system uses qemu to start a new process.

[0080] In summary, in the method provided in the present application, fuzz testing using afl-qemu in a child process is implemented by modifying the way to start a new process. Specifically, when starting a new process, the original executable program is replaced with the qemu program, and the original executable program is passed to it as a parameter of qemu. In this way, when the operating system starts a new process, qemu will be used to start the process, so that the child process can also obtain coverage information and participate in fuzz testing.

[0081] In terms of code implementation, the startup function of afl-qemu is modified to replace the execution program with the qemu program by calling the execve function, and the original execution program and its parameters are passed to it as parameters of the execve function. In this way, when a new process is started, qemu will be used to start the process and run the original execution program in it, thus achieving the purpose of fuzz testing afl-qemu in the child process.

[0082] The purpose of the embodiment of the present application is to add multi-process fuzz testing support to afl-qemu, so that afl-qemu is used to start a new process, so that the child process can also obtain coverage. In addition, the embodiment of the present application also designs the judgment of whether the ELF executable file is an executable program of this architecture, and the logic of processing the script header (shebang) when the started program is a script.

[0083] The key to the method provided by the present application is to change the startup mode of afl-qemu so that it still uses afl-qemu to start a new process, so that fuzz testing can be performed on multiple processes. In addition, by detecting ELF files and processing shebang, afl-qemu can correctly process various types of executable files and script files.

[0084] The method provided in this application can implement fuzz testing of multiple processes by afl-qemu, improving the effect and efficiency of fuzz testing. At the same time, by correctly processing various types of executable files and script files, the application scope of afl-qemu is wider and can handle more types of test scenarios.

[0085] It should be understood that although Figure 1-2 The steps in the flowchart are shown in sequence as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of these steps, and these steps can be executed in other orders. Moreover, Figure 1-2 At least part of the steps may include multiple steps or multiple stages. These steps or stages are not necessarily performed at the same time, but can be performed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed in turn or alternately with other steps or at least part of the steps or stages in other steps.

[0086] In one embodiment, Figure 3 As shown, a multi-process fuzzy testing device based on QEMU is provided, including the following program modules:

[0087] The category determination module 301 is used to determine the category of the executed program when the executed program starts a new process;

[0088] The parameter list extraction module 302 is used to parse the script header of the executed program if it is determined that the executed program is a script file, and extract the parameter list required to start the script interpreter from the script header of the executed program;

[0089] If it is determined that the executed program is an ELF file, determine whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, extract a parameter list from the executed program;

[0090] The path adding module 303 is used to add the path of the QEMU program before the obtained parameter list, and pass the parameter list with the path of the QEMU program added to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and perform fuzzy testing on the new process through the QEMU program.

[0091] The specific implementation content of each module can be found in the above definition of a multi-process fuzz testing method based on QEMU, which will not be repeated here.

[0092] In one embodiment, a computer device is provided. The computer device may be a terminal, and its internal structure diagram may be as follows: Figure 4 As shown. The computer device includes a processor, a memory, a communication interface, a display screen and an input device connected via a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities, and the communication interface is used to communicate with an external terminal in a wired or wireless manner. The wireless method can be achieved through WIFI, an operator network, NFC (near field communication) or other technologies. The computer device implements the above-mentioned multi-process fuzz testing method based on QEMU by loading and running a computer program. The display screen of the computer device can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer device can be a touch layer covered on the display screen, or a button, trackball or touchpad set on the computer device housing, or an external keyboard, touchpad or mouse, etc.

[0093] Those skilled in the art will understand that Figure 4 The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have a different arrangement of components.

[0094] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored, which involves all or part of the processes in the above-mentioned embodiment method.

[0095] The technical features of the above embodiments may be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

Claims

1. A multi-process fuzz testing method based on QEMU, It is characterized in that include: S1, when the executed program starts a new process, determining the type of the executed program; S2, if it is determined that the executed program is a script file, parsing the script header of the executed program, and extracting a parameter list required to start a script interpreter from the script header of the executed program; If it is determined that the executed program is an ELF file, determining whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, extracting a parameter list from the executed program; S3, adding the path of the QEMU program before the obtained parameter list, and handing the parameter list with the path of the QEMU program added to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and performing fuzz testing on the new process through the QEMU program; Specifically, the path of the QEMU program is added before the obtained parameter list, and the parameter list after the QEMU program path is added is handed over to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, including: Get the path of the QEMU program: First, you need to determine the path of the QEMU program in the system; Get the QEMU executable file path through the configuration file, environment variable or directly specify the path; Build a new parameter list: Combine the obtained QEMU path with the original parameter list to build a new parameter list; this new parameter list will be used as a parameter of the execve function to start a new process; Call the execve function: Use the execve function provided by the operating system and pass the new parameter list to the function; the execve function loads the QEMU executable file and replaces the code and data segments of the current process with it. At the same time, the new parameter list is passed to QEMU so that QEMU uses these parameters when starting a new process; The operating system starts a new process: After calling the execve function, the operating system will load the QEMU executable file according to the passed parameter list and start a new process. The new process will use QEMU as the execution environment to execute the program under test.

2. The QEMU-based multi-process fuzz testing method according to claim 1, It is characterized in that If the executed program is a file beginning with ASCII character #!, it is determined that the executed program is a script file; otherwise, it is determined that the executed program is an ELF file.

3. The QEMU-based multi-process fuzz testing method according to claim 1, It is characterized in that The step of determining whether the executed program is an executable program of the current operating system comprises: Obtaining header information of the executed program, and extracting an identifier of the target operating system from the header information; Determine whether the identifier of the target operating system matches the current operating system; if they match, determine that the executed program is an executable program of the current operating system.

4. The QEMU-based multi-process fuzz testing method according to claim 1, It is characterized in that Step S2 also includes: When parsing the script header of the executed program, if the script header of the executed program is illegal, output an error warning prompt; When determining whether the executed program is an executable program of the current operating system, if it is determined that the executed program is not an executable program of the current operating system, an error warning prompt is output.

5. The QEMU-based multi-process fuzz testing method according to claim 1, It is characterized in that In step S3, the current operating system calls the execve function to enable the current operating system to start a new process using the QEMU program.

6. A multi-process fuzz testing device based on QEMU, It is characterized in that include: A category determination module, used to determine the category of the executed program when the executed program starts a new process; A parameter list extraction module is used to parse the script header of the executed program if it is determined that the executed program is a script file, and extract the parameter list required to start the script interpreter from the script header of the executed program; If it is determined that the executed program is an ELF file, determining whether the executed program is an executable program of the current operating system; if it is determined that the executed program is an executable program of the current operating system, extracting a parameter list from the executed program; A path adding module is used to add the path of the QEMU program before the obtained parameter list, and to hand over the parameter list with the path of the QEMU program added to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, so that the QEMU program can obtain the coverage of the new process; and to perform fuzzy testing on the new process through the QEMU program; Specifically, the path of the QEMU program is added before the obtained parameter list, and the parameter list after the QEMU program path is added is handed over to the current operating system for execution, so that the current operating system uses the QEMU program to start a new process, including: Get the path of the QEMU program: First, you need to determine the path of the QEMU program in the system; Get the executable file path of QEMU through configuration files, environment variables or by directly specifying the path; Build a new parameter list: Combine the obtained QEMU path with the original parameter list to build a new parameter list; this new parameter list will be used as a parameter of the execve function to start a new process; Call the execve function: Use the execve function provided by the operating system and pass the new parameter list to the function; the execve function loads the QEMU executable file and replaces the code and data segments of the current process with it. At the same time, the new parameter list is passed to QEMU so that QEMU uses these parameters when starting a new process; The operating system starts a new process: After calling the execve function, the operating system will load the QEMU executable file according to the passed parameter list and start a new process. The new process will use QEMU as the execution environment to execute the program under test.

7. A computer device comprising a memory and a processor, wherein the memory stores a computer program, It is characterized in that When the processor executes the computer program, the steps of the method according to any one of claims 1 to 5 are implemented.

8. A computer-readable storage medium having a computer program stored thereon, It is characterized in that When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 5 are implemented.