State diagram-based kernel memory vulnerability mining method and device and computer equipment
By generating a state graph summarizing memory management variables and functions, and combining it with kernel vulnerability discovery tools and fuzzing tools, the problem of difficult-to-discover kernel memory vulnerabilities was solved, achieving highly efficient vulnerability discovery results.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- ZHEJIANG UNIV
- Filing Date
- 2024-12-06
- Publication Date
- 2026-06-09
AI Technical Summary
Existing technologies are insufficient for effectively and efficiently discovering operating system kernel memory vulnerabilities. Static analysis tools have high false positive rates, dynamic monitoring has low coverage, and fuzzing is inefficient in kernel space, making vulnerability discovery difficult.
By generating a state graph representing memory management variables and function summaries, the state graph is simplified using lock set analysis. Potential error states are identified using kernel vulnerability discovery tools, and system call sequences are generated and input into kernel fuzzing tools for testing.
It improves the efficiency and accuracy of kernel memory vulnerability discovery, reduces the test search space, and enhances the coverage and efficiency of vulnerability discovery.
Smart Images
Figure CN122173386A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of cyberspace security technology, and in particular to a kernel memory vulnerability mining method, apparatus, and computer equipment based on state diagrams. Background Technology
[0002] Kernel memory vulnerabilities refer to security flaws existing in the operating system kernel, typically involving issues related to memory management and data processing. Common memory vulnerabilities include buffer overflows, use after free, and race conditions. The severity of these vulnerabilities lies in the fact that the kernel, as the core of the operating system, is responsible for directly interacting with hardware and controlling system resources. Once exploited by attackers, kernel memory vulnerabilities can lead to serious consequences such as system crashes, privilege escalation, data leaks, and even the acquisition of control of the entire system. These vulnerabilities have a wide-ranging impact, potentially posing serious security risks to individual users, and even enterprises and organizations; therefore, the discovery and remediation of kernel memory vulnerabilities are of paramount importance.
[0003] In current technologies, the discovery of kernel memory vulnerabilities mainly relies on techniques such as static analysis, dynamic monitoring, and fuzzing. However, these traditional methods each have significant limitations. First, static analysis tools discover potential security issues by statically scanning the code. Although static analysis can identify some obvious errors in the early stages, it is difficult to capture all potential vulnerabilities because kernel code is typically complex and dynamic. These tools often generate a large number of false positives when dealing with complex logic and data flows, exposing researchers to excessive invalid alerts and thus wasting time and resources.
[0004] Secondly, dynamic monitoring methods monitor program behavior at runtime, attempting to capture anomalies by observing the actual execution process. While this approach can effectively capture certain runtime errors, it cannot cover all execution paths, especially in kernel space, where vulnerabilities that only trigger under specific conditions are often difficult to discover. Furthermore, because its test cases rely on manual generation, it cannot be applied on a large scale to multiple types and versions of kernels.
[0005] Finally, fuzzing tests program stability by inputting random or invalid data. While it performs well in user-space applications, its efficiency and effectiveness decrease significantly in kernel space. This is because, although fuzzing can automatically generate a large number of test cases, it cannot effectively analyze complex memory state dependencies, resulting in insufficient ability to identify and trigger memory errors. Summary of the Invention
[0006] Therefore, it is necessary to provide a kernel memory vulnerability discovery method, apparatus, and computer equipment based on state diagrams to address the aforementioned technical problems.
[0007] In a first aspect, embodiments of this application provide a kernel memory vulnerability mining method based on state diagrams, the method comprising:
[0008] Obtain the kernel source code file to be analyzed;
[0009] The kernel source code file to be analyzed is analyzed to generate a state diagram represented by memory management variables and function summaries;
[0010] For the aforementioned state diagram, a constructed kernel vulnerability discovery tool is used to identify potential memory error states and generate corresponding system call sequences;
[0011] The system call sequence is input into the kernel fuzzing tool, which outputs the corresponding test results and test effects.
[0012] In some embodiments, the analysis of the kernel source code file to be analyzed to generate a state diagram represented by memory management variables and function summaries includes:
[0013] Convert the kernel source code file into an abstract syntax tree;
[0014] Scan the header file to obtain the structure of all memory objects, associate the different structures to form multiple tree-like structure definition graphs, use the structure definition graphs to find the initialization position of each structure in the abstract syntax tree, and obtain the memory management variables;
[0015] Using taint tracing technology, function summaries in the kernel source code file are identified;
[0016] The state graph is dynamically generated by using the memory management variables as nodes and the function summaries as edges.
[0017] In some embodiments, generating the state graph by using the memory management variable as a node and the function summary as an edge includes:
[0018] The state diagram is defined as G = (V, E), where V represents the state of a memory object, E represents the state transition function (V, F) → V, and F represents the operation function of a memory object.
[0019] Based on the defined state diagram, lock set analysis is used to identify the locking and unlocking operations of the operation functions, identify the operation functions that cannot be executed under specific states, and then identify unreachable states to simplify the state diagram.
[0020] In some embodiments, the step of identifying potential memory error states using a constructed kernel vulnerability discovery tool and generating corresponding system call sequences for the state graph includes:
[0021] For multiple memory management variables under the same structure or memory management variables under substructures, analyze whether the variable names of the memory management variables conflict;
[0022] Based on the conflicting memory management variables, a path is obtained from the state graph, potential error states are found, and then the corresponding function sequence is output, generating the corresponding system call sequence.
[0023] In some embodiments, inputting the system call sequence into a kernel fuzzing tool and outputting the corresponding test results and test effects includes:
[0024] The system call sequence is formatted into a corresponding input template and used as input for testing by the kernel fuzzing tool;
[0025] During the testing process, the system call sequence is specifically transformed, including inserting new system call sequences, swapping the order of system call sequences, and modifying the parameters of system call sequences.
[0026] In some embodiments, the input template is:
[0027] syscallname"("[arg[","arg]*]")"[type]["("attribute*")"]
[0028] Wherein, syscallname represents the name of the system call sequence, arg represents the parameters of the system call sequence, type represents the return type of the current system call sequence, and attribute represents the state of the input template.
[0029] In some embodiments, the test results include code coverage, and the method further includes:
[0030] Based on the code coverage feedback mechanism, the kernel source code file is instrumented, and a hook function is added to each basic block. Each time a specific function is executed, the hook function record will be called.
[0031] In some embodiments, the test results include page table operation frequency, and the method further includes:
[0032] Based on the feedback mechanism of page table operations, instrumentation is performed at the page table allocation, release, and modification functions to record the frequency of page table operations and guide the direction of fuzz testing.
[0033] Secondly, embodiments of this application provide a kernel memory vulnerability mining apparatus based on a state diagram, the apparatus comprising:
[0034] The code acquisition module is used to acquire the kernel source code file to be analyzed.
[0035] The state diagram construction module is used to analyze the kernel source code file to be analyzed and generate a state diagram represented by memory management variables and function summaries.
[0036] The sequence generation module is used to identify potential memory error states using a constructed kernel vulnerability mining tool for the state graph, and generate corresponding system call sequences.
[0037] The sequence testing module is used to input the system call sequence into the kernel fuzzing tool and output the corresponding test results and test effects.
[0038] Thirdly, embodiments of this application provide a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method described in the first aspect.
[0039] This application has the following advantages: First, it analyzes the kernel source code file to be analyzed, generating a state diagram represented by memory management variables and function summaries, which can accurately identify kernel memory state changes and locate abnormal states. The system call sequence based on the state diagram can effectively reduce the test search space, thereby improving vulnerability discovery efficiency. Attached Figure Description
[0040] Figure 1 This is a flowchart illustrating a kernel memory vulnerability discovery method based on a state diagram according to an embodiment of the present invention.
[0041] Figure 2 This is a flowchart illustrating a state diagram generation method in one embodiment of the present invention;
[0042] Figure 3 This is a schematic diagram of a state diagram in an example embodiment of the present invention;
[0043] Figure 4 This is a flowchart illustrating a system call sequence generation method in one embodiment of the present invention;
[0044] Figure 5 This is a flowchart illustrating a fuzzy testing method according to an embodiment of the present invention;
[0045] Figure 6 This is a schematic diagram of the module connections of a kernel memory vulnerability mining device based on a state diagram according to an embodiment of the present invention;
[0046] Figure 7 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation
[0047] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are merely some examples or embodiments of the present invention. For those skilled in the art, the present invention can be applied to other similar scenarios based on these drawings without creative effort. Unless obvious from the context or otherwise specified, the same reference numerals in the drawings represent the same structures or operations.
[0048] As indicated in this invention and the claims, unless the context clearly indicates otherwise, the words "a," "an," "an," and / or "the" do not specifically refer to the singular and may also include the plural. Generally speaking, the terms "comprising" and "including" only indicate the inclusion of explicitly identified steps and elements, which do not constitute an exclusive list, and the method or apparatus may also include other steps or elements.
[0049] While this invention makes various references to certain modules in systems according to embodiments of the invention, any number of different modules can be used and run on computing devices and / or processors. Modules are merely illustrative, and different aspects of the system and method may use different modules.
[0050] It should be understood that when a unit or module is described as "connected" or "coupled" to other units, modules, or blocks, it may refer to a direct connection or coupling, or communication with other units, modules, or blocks, or the presence of intermediate units, modules, or blocks, unless the context explicitly indicates otherwise. The term "and / or" as used herein may include any and all combinations of one or more of the related listed items.
[0051] like Figure 1 As shown in the embodiments of this application, a kernel memory vulnerability mining method based on state graphs is also proposed, the method comprising:
[0052] S102: Obtain the kernel source code file to be analyzed;
[0053] S204: Analyze the kernel source code file to be analyzed and generate a state diagram represented by memory management variables and function summaries;
[0054] S106: For the aforementioned state diagram, use the constructed kernel vulnerability mining tool to identify potential memory error states and generate corresponding system call sequences;
[0055] S108: Input the system call sequence into the kernel fuzzing tool and output the corresponding test results and test effects.
[0056] In this embodiment, the kernel source code file to be analyzed is first analyzed to generate a state graph represented by memory management variables and function summaries, which can accurately identify kernel memory state changes and locate abnormal states. The system call sequence based on the state graph can effectively reduce the test search space, thereby improving vulnerability discovery efficiency.
[0057] In some embodiments, such as Figure 2 As shown, the analysis of the kernel source code file to be analyzed, and the generation of a state diagram represented by memory management variables and function summaries, includes:
[0058] S202: Convert the kernel source code file into an abstract syntax tree;
[0059] S204: Scan the header file to obtain the structure of all memory objects, associate the different structures to form multiple tree-like structure definition graphs, use the structure definition graphs to find the initialization position of each structure in the abstract syntax tree, and obtain memory management variables;
[0060] S206: Using taint tracing technology, identify function summaries in the kernel source code file;
[0061] S208: Using the memory management variables as nodes and the function summaries as edges, dynamically generate the state graph.
[0062] First, the collected kernel source code files are converted into an abstract syntax tree (AST). This code representation is beneficial for further program analysis. In this specific embodiment, the LLVM analyzer is used to convert the kernel source code files into an AST representation, but other parsers can also be used.
[0063] Specifically, a lexical analyzer and a syntax analyzer are used to identify all structures defined in the header files of the kernel source code files. Then, based on the structure names, different structures are associated to form multiple abstract syntax trees. Using these abstract syntax trees and the characteristic that variables need to be assigned initial values during structure initialization, the initialization position of each structure in the abstract syntax tree is found.
[0064] In one implementation, regular expressions are used to match struct type structures. The member variables in these structures may be variables of another struct type, or variables of types such as char, int, and double. Then, by matching variable names, variables of different struct types are connected to form a tree-like structure definition graph.
[0065] Then, techniques such as taint analysis are needed to compute the function summary. The function summary is represented as a triple.<R,W,C> Here, R represents the set of memory management variables read by the function, W represents the set of memory management variables written by the function, and C represents the set of hash values of the functions called by the function. R and W represent the memory management variables operated on by the function. After the current state is operated on by this function, it will transition to a specific state. Except for the variables contained in W, the values of other variables in this state are the same as the current state. C represents the set of hash values of the functions called by the function. When calculating the function digest, the function digests of the sub-functions are recursively calculated to fully consider the operated variables. Therefore, when constructing the state diagram, the impact of the sub-functions can be recursively considered for a specific system call, thereby assisting in the generation of the state diagram.
[0066] In one implementation, the angr analysis tool is used to perform taint analysis on the code, identifying data flow relationships within and between functions to construct a function summary. First, for variables passed as parameters or initialized locally within a function, the angr analysis tool calculates the corresponding taint propagation paths and conditions. When encountering conditional branches, the variable conditions required for executing a specific path of the branch are calculated by starting a child process. However, this method can lead to state explosion. To address this, the instruction depth explored by the angr analysis tool is limited before analysis, and it automatically returns when a certain depth is reached. In this way, the variables read and modified by the function, as well as other functions called during the function's execution, are calculated.
[0067] Finally, a state graph is generated using a set of memory management variables and a function summary, and the size of the state graph is reduced using lock set analysis techniques.
[0068] The state graph generated based on the memory object state and function summary is defined as G = (V, E), where V represents the memory object state, E represents the state transition function (V, F) → V, and F represents an operation function of a memory object. First, a set of memory management variables is used, where each variable is a boolean variable (e.g., an int variable is False when its value is 0 and True when it is not 0; a pointer variable is False when its value is null and True when it is not null). Then, all states are generated using the Cartesian product of these variables. Next, every possible function is applied to each state. If the function summary indicates that a specific memory management variable will be modified, the current state will transition to the state where the corresponding variable has been modified after passing through that function. This dynamically constructs a state graph.
[0069] This step also includes detecting unreachable states after the state graph is generated. By analyzing the mutex operations within the functions, critical sections are identified, and the state transition targets caused by the corresponding functions are marked as unreachable, thereby reducing the complexity of the state graph.
[0070] Figure 3 This is a schematic diagram of a state diagram in an example embodiment. Figure 3 The states of memory management variables, such as "non-evictable memory" and "evictable memory", include normal and abnormal states. "kbase_mem_evictable_init" and "kbase_jit_free_finish" are function names.
[0071] In some embodiments, such as Figure 4 As shown, the process of identifying potential memory error states using a constructed kernel vulnerability discovery tool and generating corresponding system call sequences for the state diagram includes:
[0072] S302: For multiple memory management variables under the same structure or memory management variables under a substructure, analyze whether the variable names of the memory management variables conflict;
[0073] S304: Based on the conflicting memory management variables, obtain a path in the state graph, find the potential error state, and then output the corresponding function sequence and generate the corresponding system call sequence.
[0074] By constructing a kernel vulnerability discovery tool, this tool identifies potential memory error states and instructs the generation of system call sequences. The tool first analyzes the extracted set of memory management variables, examining potential name conflicts among multiple variables within the same structure or variables within substructures. Then, based on the operations on these conflicting variables, it obtains multiple paths in the state graph, identifies potential error states, and outputs the corresponding function sequences, generating the appropriate system call sequences.
[0075] In some embodiments, such as Figure 5 As shown, the step of inputting the system call sequence into the kernel fuzzing tool and outputting the corresponding test results and effects includes:
[0076] S402: Format the system call sequence into a corresponding input template and use it as input to the kernel fuzzing tool for testing;
[0077] S404: During the test, the system call sequence is transformed in a targeted manner, including inserting a new system call sequence, swapping the order of system call sequences, and modifying the parameters of the system call sequence.
[0078] This method uses the system call sequence generated in the previous step as input for fuzzing to uncover kernel memory vulnerabilities, and combines multiple test result feedback mechanisms to improve vulnerability discovery effectiveness. First, the system call sequence is formatted and used as input for kernel fuzzing. Simultaneously, a fuzzing module is written to specifically transform the system calls, including inserting new system call sequences, swapping the order of system call sequences, and modifying the parameters of system call sequences.
[0079] In one implementation, the generated system call sequence serves as the input template for Syzkaller:
[0080] syscallname"("[arg[","arg]*]")"[type]["("attribute*")"]
[0081] `syscallname` represents the kernel driver's system call name, `arg` represents the system call parameters, consisting of the parameter name and type, `type` represents the current system call return type, and `attribute` indicates whether the current system call template is used during the actual program generation, and the conditions for its use. The state construction module generates a state graph, thus generating a sequence of system calls that may lead to abnormal states. This implementation example formats system calls into Syzkaller's input template, i.e., a system call description containing multiple parts: `syscallname`, `arg`, `type`, and `attribute`. Simultaneously, the corresponding system call sequences are input into the kernel fuzzing tool, generating seed test programs containing multiple system call sequences. Syzkaller uses these seed test programs as the initial test programs for fuzzing and continuously changes the seed programs based on the previously generated template during the testing process, attempting to discover programs that may cause errors.
[0082] The testing module also includes various test result feedback mechanisms to significantly improve the efficiency of vulnerability discovery.
[0083] The first feedback mechanism is based on code coverage. It detects code coverage during kernel execution; the higher the code coverage, the more code is executed, and the more likely a vulnerability is to be triggered. This is achieved by instrumenting the kernel source code, adding hook functions to each basic block, and calling and recording the hook function every time a specific function is executed.
[0084] The second feedback mechanism is based on the frequency of page table operations. Code coverage cannot fully reflect memory-related operations. Memory operations require the allocation and release of page tables; therefore, the frequency of page table operations reflects the extent of memory operations in the current test case. By instrumenting multiple functions (such as `map_pages`, `unmap_page_range`, etc.) related to page table allocation, release, and modification, the frequency of page table operations is recorded, guiding the direction of fuzzing and effectively improving the efficiency of kernel memory-related vulnerability discovery.
[0085] Based on the same inventive concept, such as Figure 6 As shown, a second aspect of the present invention provides a kernel memory vulnerability mining apparatus based on a state graph, the apparatus comprising:
[0086] The code acquisition module 502 is used to acquire the kernel source code file to be analyzed;
[0087] The state diagram construction module 504 is used to analyze the kernel source code file to be analyzed and generate a state diagram represented by memory management variables and function summaries.
[0088] The sequence generation module 506 is used to identify potential memory error states using a constructed kernel vulnerability mining tool for the state diagram, and generate corresponding system call sequences.
[0089] The sequence testing module 508 is used to input the system call sequence into the kernel fuzzing tool and output the corresponding test results and test effects.
[0090] Each module in the above-mentioned device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of a computer device in hardware form or independent of it, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.
[0091] In one exemplary embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 7As shown, the computer device includes a processor, memory, input / output interfaces (I / O), and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage medium. The database stores data. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communicating with external terminals via a network connection. When the computer program is executed by the processor, it implements the method described in the above embodiment.
[0092] Those skilled in the art will understand that Figure 7 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.
[0093] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, or optical storage, etc. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc.
[0094] The technical features of the above embodiments can be combined in any way. For the sake of brevity, 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.
[0095] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.
Claims
1. A kernel memory vulnerability discovery method based on state graphs, characterized in that, The method includes: Obtain the kernel source code file to be analyzed; The kernel source code file to be analyzed is analyzed to generate a state diagram represented by memory management variables and function summaries; For the aforementioned state diagram, a constructed kernel vulnerability discovery tool is used to identify potential memory error states and generate corresponding system call sequences; The system call sequence is input into the kernel fuzzing tool, which outputs the corresponding test results and test effects.
2. The method according to claim 1, characterized in that, The process of analyzing the kernel source code file to be analyzed and generating a state diagram represented by memory management variables and function summaries includes: Convert the kernel source code file into an abstract syntax tree; Scan the header file to obtain the structure of all memory objects, associate the different structures to form multiple tree-like structure definition graphs, use the structure definition graphs to find the initialization position of each structure in the abstract syntax tree, and obtain the memory management variables; Using taint tracing technology, function summaries in the kernel source code file are identified; The state graph is dynamically generated by using the memory management variables as nodes and the function summaries as edges.
3. The method according to claim 2, characterized in that, The step of generating the state graph by using the memory management variables as nodes and the function summary as edges includes: The state diagram is defined as G = (V, E), where V represents the state of a memory object, E represents the state transition function (V, F) → V, and F represents the operation function of a memory object. Based on the defined state diagram, lock set analysis is used to identify the locking and unlocking operations of the operation functions, identify the operation functions that cannot be executed under specific states, and then identify unreachable states to simplify the state diagram.
4. The method according to claim 2, characterized in that, The process of identifying potential memory error states using a constructed kernel vulnerability discovery tool and generating corresponding system call sequences for the aforementioned state diagram includes: For multiple memory management variables under the same structure or memory management variables under substructures, analyze whether the variable names of the memory management variables conflict; Based on the conflicting memory management variables, a path is obtained from the state graph, potential error states are found, and then the corresponding function sequence is output, generating the corresponding system call sequence.
5. The method according to claim 1, characterized in that, The step of inputting the system call sequence into the kernel fuzzing tool and outputting the corresponding test results and test effects includes: The system call sequence is formatted into a corresponding input template and used as input for testing by the kernel fuzzing tool; During the testing process, the system call sequence is specifically transformed, including inserting new system call sequences, swapping the order of system call sequences, and modifying the parameters of system call sequences.
6. The method according to claim 5, characterized in that, The input template is: syscallname"("[arg[","arg]*]")"[type]["("attribute*")"] Wherein, syscallname represents the name of the system call sequence, arg represents the parameters of the system call sequence, type represents the return type of the current system call sequence, and attribute represents the state of the input template.
7. The method according to claim 1, characterized in that, The test results include code coverage, and the method further includes: Based on the code coverage feedback mechanism, the kernel source code file is instrumented, and a hook function is added to each basic block. Each time a specific function is executed, the hook function record will be called.
8. The method according to claim 7, characterized in that, The test results include page table operation frequency, and the method further includes: Based on the feedback mechanism of page table operations, instrumentation is performed at the page table allocation, release, and modification functions to record the frequency of page table operations and guide the direction of fuzz testing.
9. A kernel memory vulnerability discovery device based on state diagrams, characterized in that, The device includes: The code acquisition module is used to acquire the kernel source code file to be analyzed. The state diagram construction module is used to analyze the kernel source code file to be analyzed and generate a state diagram represented by memory management variables and function summaries. The sequence generation module is used to identify potential memory error states using a constructed kernel vulnerability mining tool for the state graph, and generate corresponding system call sequences. The sequence testing module is used to input the system call sequence into the kernel fuzzing tool and output the corresponding test results and test effects.
10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 7.