A software testing method and device for software update
By combining static and dynamic analysis in software testing, the FCEP method is used to optimize the test input generation using the goal-based search strategy, the path explosion problem in software patch testing is solved, and efficient and accurate patch testing is achieved, ensuring the correctness of patches and reliability.
Patent Information
- Application Number
- CN202110480937.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2021-04-30
- Publication Date
- 2024-11-05
- Estimated Expiration
- 2041-04-30
AI Technical Summary
The prior art is difficult to effectively explore and test all possible execution paths introduced by software patches in software testing, resulting in path explosion problems, and manually writing test programs is time-consuming and expensive, and it is impossible to quickly generate test cases covering actual program code changes.
Using the FCEP method based on concolic execution, combined with static and dynamic analysis, by establishing control flow diagrams and function call diagrams, optimizing test input generation using goal-based search strategies, dynamically adjusting search targets, avoid exploring redundant paths, and ensuring the correct patches Sex and reliability.
It significantly reduces the number of exploration paths and the time cost of reaching patch-related code, improves the efficiency and accuracy of software patch testing, and ensures the correctness and reliability of patches.
Smart Images

Figure CN113297070B_ABST
Abstract
Description
Technical Field
[0001] The present invention belongs to the technical field of software security testing, and in particular relates to a software testing method and device for software updating. Background Art
[0002] The extensibility of software is both a blessing and a curse. On the one hand, software patches can easily add new features or fix software bugs. On the other hand, any software change may bring unexpected bugs and security vulnerabilities, which is a disaster for users and makes users reluctant to update their software. In fact, many people would rather use an earlier version of software that contains serious bugs and fewer features than upgrade their software to the latest version. In order to reduce program errors and improve user experience, developers must thoroughly test their programs before releasing them. However, software testing is expensive and time-consuming, because a large part of the cost of software maintenance is related to detecting and fixing bugs. Program patches, as a typical form of software changes, should ideally be fully tested, at least every line in the patch, and every line of code in the original code that may be affected by the patch should contain at least one test case. But this level of testing is still far away in current practice.
[0003] Currently, a large part of the software development cycle is spent manually writing a large number of test programs that verify various paths. The goal of these test programs is to maximize the coverage of a specific range, such as covered paths or branch ranges, but this is a tedious process that requires a lot of work and a good understanding of the system under test. In the past few years, we have seen significant progress in test generation techniques. Many of these techniques are based on concolic execution (Cristian Cadar and Koushik Sen. 2013. "Symbolic execution for software testing: three decades later," Commun. ACM 56, 2 (2013), 82–90.), which is a program analysis technique based on dynamic symbolic execution that is able to generate inputs for high-coverage test suites. It has been shown to be a good choice for comprehensive testing of real software because it can systematically explore different program paths and accurately perform memory reasoning.
[0004] Most of the work on concolic execution focuses on "whole program" testing, where all parts of the program are treated equally. However, the number of execution paths in a program is typically exponentially related to the number of branches, so exploring all possible execution paths is infeasible. That is, conservative execution faces the challenge of path explosion, which makes this approach somewhat inadequate when faced with test input generation for specific paths (such as those affected by patches), so effective search strategies are very important to overcome the path explosion challenge during patch testing. Although some research has made new progress in achieving high-coverage patch-oriented testing techniques, they are still far from the goal of quickly and automatically generating test cases that contain code changes in actual programs. Summary of the invention
[0005] The present invention develops a software testing method and device for software update, which is used to implement software automatic testing based on concolic execution. The method is called FCEP (Fast Concolic Execution for Patches) to ensure the correctness and reliability of the patch. The method uses the advantages of static and dynamic analysis to generate test inputs to cover the changed lines in the patch. FCEP does not explore all branches in the candidate list, but selects branches based on the distance between the untested state and the target (such as the line in the patch). FCEP combines the exploration of the patch with the exploration of the function where the patch is located, and dynamically adjusts the search target to perform a more comprehensive test on the function where the patch is located.
[0006] The technical solution adopted by the present invention is as follows:
[0007] A software testing method for software update, comprising the following steps:
[0008] Create a control flow graph CFG and function call graph CG of the new version of the binary program, mark the possible execution paths of the core target in CFG, and mark the corresponding function call relationships in CG;
[0009] During the concolic execution of the new version of the binary program, when the execution path encounters a branch, a new state is created for the execution path, and then the address of the next instruction is found in the CFG for the new state, the new state is mapped to the address of the next instruction, and the new state is put into the candidate list;
[0010] When a path is executed, a goal-based search strategy is used to select a new state that falls into the target function from the candidate list to continue the concolic execution.
[0011] Furthermore, the patches are grouped according to the functions to which they belong, and a row of the patch is selected in each group as the core target, which row represents the core part of the function modification as much as possible.
[0012] Furthermore, if an indirect jump or function pointer call is encountered during the concolic execution, the CFG and CG are dynamically modified to obtain accurate path information.
[0013] Furthermore, the target-based search strategy infers the paths covered by the patch and the related paths of the function where the patch is located, and directs the search to these paths to avoid exploring a large number of redundant paths.
[0014] Furthermore, the target-based search strategy includes:
[0015] When a path is executed, determine whether the next instruction address of the new state in the candidate list hits the target function, that is, the function where the patch is located;
[0016] If hit, assign the highest priority to all hit new states, select a path closest to the core target in the new state with the highest priority to continue running, and after the path is executed, continue to select the execution path in the new state with the highest priority;
[0017] If there is no hit, or the new state with the highest priority has been fully executed, the upper-level calling function of the target function is searched in combination with CFG and CG, and it is confirmed whether there is a new state in the candidate list that hits the upper-level calling function; among the new states that hit the upper-level calling function, a new state closest to the calling point is selected to continue execution.
[0018] Furthermore, using formula D i =|state i _addr-target_addr|Calculate the distance between the new state and the target, and select the new state closest to the target, where Di represents the distance, state i _addr indicates the next instruction address of the new state, and target_addr indicates the target address; target_addr is the address of the patch line determined before running the program. When no new state hits the target function, target_addr is the address of the function call line in the call chain of the target function.
[0019] Furthermore, during the concolic execution process, if a branch is encountered, the states of the two generated branches are added to the execution tree, and the positive branch is placed in the left subtree and the negative branch is placed in the right subtree, that is, when a new state is created, the positive and negative branches of the state are adjusted to be consistent with the CFG generated in the static analysis.
[0020] A software testing device for software update using the above method comprises:
[0021] The address mapping module is used to establish the control flow graph CFG and function call graph CG of the new version binary program, mark the possible execution paths of the core target in the CFG, and mark the corresponding function call relationship in the CG; during the concolic execution of the new version binary program, when the execution path encounters a branch, a new state is created for the execution path, and then the address of the next instruction is found for the new state in the CFG, the new state is mapped to the address of the next instruction, and the new state is put into the candidate list;
[0022] The target-based search module is used to select a new state that falls into the target function from the candidate list using a target-based search strategy to continue running the concolic execution after a path is executed.
[0023] The advantages and beneficial effects of the present invention are as follows:
[0024] Concolic execution is commonly used for software testing, but it faces challenges such as path explosion caused by huge search paths. Effective search strategies are very important to overcome the challenges of search space. Software updates can easily introduce errors, so comprehensive testing of software patches is essential. The present invention proposes a technology based on concolic execution to ensure the correctness and reliability of patches. The method generates test inputs by using a target-based search strategy to cover the changed lines and related functions of the patch, and implements a prototype system called FCEP. The present invention takes software patches as potential targets for testing, combines the advantages of static analysis in concolic execution to improve the efficiency of searching for potential targets, and can exclude uninteresting code parts during the test process, focusing more on those paths that are most relevant to potential targets. FCEP can bring significant improvements in reducing the number of exploration paths and the time cost of reaching patch-related code. BRIEF DESCRIPTION OF THE DRAWINGS
[0025] Figure 1 This is the overall block diagram of FCEP.
[0026] Figure 2 is a search strategy example diagram. DETAILED DESCRIPTION
[0027] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the present invention is further described in detail below through specific embodiments and drawings.
[0028] The purpose of software updates is to bring new features or fix existing bugs to users, but software updates usually bring new bugs, which seriously affects the user experience and makes users often hesitate whether to update the software. Therefore, program testing is essential before software is released. At least each line in the code that may be affected by the patch should contain at least one test case. However, software testing is time-consuming and expensive. More and more researchers are committed to developing new technologies that can automatically generate high-coverage test suites and detect software errors introduced by patches. The present invention proposes a technology based on concolic execution, which combines static analysis and dynamic analysis to generate test inputs to cover the changed lines in the patch, and comprehensively tests the functions where the patch is located, so as to ensure the correctness and reliability of the patch, and implements a prototype system called FCEP.
[0029] 1. Background knowledge
[0030] Concolic execution is an automatic test generation technique based on symbolic execution. It is an analysis technique that can systematically explore program paths. The word "concolic" is a derivative of the words "concrete" and "symbolic". The key idea behind it is to run the program using symbolic values instead of concrete values. If a branch is encountered that depends directly or indirectly on symbolic input, concolic execution will determine the feasibility of both sides of the branch and create two independent symbolic states for analysis. In this process, concolic execution needs to maintain the symbolic value, concrete value, and path constraints of each path. After selecting the appropriate concrete value, the program is executed concretely and symbolically by updating the path constraints. Whenever the concrete execution takes a branch, the symbolic execution also points to the same branch. The constraints extracted from the branch are added to the current path constraints. In order to explore different paths, the path conditions given by one or more branches can be negated, and the solver is called to find a satisfactory assignment for the new constraint, that is, to generate a new input.
[0031] Path explosion: Since the number of execution paths in a program is usually exponential to the number of branches, it is infeasible to explore all possible execution paths. Symbolic execution can filter out two types of paths: (1) paths that do not depend on symbolic inputs; (2) paths that are unsatisfactory for the current path constraints. Although symbolic execution has filtered out paths, the path explosion problem remains one of the main challenges of symbolic execution. To address this problem, strategic execution relies on search heuristics to guide strategic execution in a way that maximizes code coverage within a given limited time budget.
[0032] Search strategies: Since enumerating all paths of a program can be very expensive, in many software engineering projects related to testing and debugging, the search is prioritized by looking at the most promising paths first. The following are several representative search strategies that try to improve the coverage of the search space.
[0033] Depth-first search (DFS) and breadth-first search (BFS) are the most common strategies. DFS expands the path as far as possible before backtracking to the deepest unexplored branch, while BFS expands all paths in parallel. DFS is often adopted when memory usage is at a premium. However, this strategy has several limitations. First, DFS may get stuck in loops or recursions when the program contains loops or recursions whose conditions depend on symbolic inputs. In addition, since it selects branches in increasing order of depth, it becomes more difficult to generate input vectors as the number of constraints involved also increases. The breadth-first search (BFS) strategy traverses the execution tree according to the BFS order. The BFS strategy prefers branches that appear earlier in the execution path, so it is easier to generate new input vectors because these branches will involve fewer constraints. Therefore, some tools adopt BFS despite the higher memory pressure and the long time required to complete the exploration of a particular path. In theory, both DFS and BFS strategies can cover all execution paths in the execution tree. But real programs have a large number of execution paths, and even these strategies cannot scale to medium-sized programs.
[0034] 2. Overall process
[0035] Figure 1 The overall block diagram of FCEP is shown. Its inputs are: 1) new version of binary program and patch; 2) test inputs selected from the test suite. Its output is a set of inputs that can trigger program crash errors or can cover the patch and its function.
[0036] On the one hand, FCEP uses a disassembler to generate the CFG (control flow graph) and CG (function call graph) of the new version of the program. It marks the location of each target (i.e., a line in the patch) in the CFG, and generates a list of function address ranges based on the CG. On the other hand, when the executor encounters a branch while running the binary program, it will create a new state for the execution path, and then use the address finder to search for the address of the next instruction for the two states (the original state and the newly generated state) in the generated CFG, and map the new state to its next instruction address, and then put the newly generated state into the candidate list to wait for the next time the path selector selects the new state to complete the concolic execution.
[0037] When the execution of the path with the initial input ends, FCEP uses a target-based search strategy in the candidate list to select a new state to continue running concolic execution, which can provide test input for the path that triggered the crash. The search strategy infers the paths covered by the patch and the related paths of the function where the patch is located, and guides the search to these paths to avoid exploring a large number of redundant paths.
[0038] Once the state of the function where the patch is located appears, the target-based search strategy will select the state that falls into the target function (i.e., the function where the patch is located) as the new state, and execute these states as much as possible to ensure the security of the patch. This is mainly because for the test of the patch, the present invention believes that covering only the patch code lines is far from meeting the test requirements for ensuring the security of the patch. In addition, in the concolic execution, if the tested path exists through indirect jumps or function pointer calls, FCEP will correct the statically generated CFG and CG to cover the indirect jumps or function pointer calls that cannot be correctly analyzed by static analysis, thereby increasing the accuracy of the FCEP test.
[0039] 3. Implementation details
[0040] 3.1 Address Mapping
[0041] 1) Generate CFG and CG
[0042] The first step in our analysis is to identify the differences between the new version of the software and its old version (i.e., the patch). In theory, every line in the patch is a potential target for FCEP. In practice, many lines can be ignored because the source code contains many non-executable lines (e.g., declarations, comments, blank lines, or lines that are not compiled into executable files). FCEP groups the patches according to the functions they belong to, and then processes the patches in each group separately in subsequent steps. In each group, a line of the patch is selected as the core target, and the line represents the core part of the function modification as much as possible. FCEP uses the IDA Pro toolset to statically analyze the new version of the software, building a control flow graph (CFG) and a function call graph (CG). FCEP marks the possible execution paths of the core targets in the CFG and the corresponding function call relationships in the CG. Note that considering that indirect jumps and pointers may cause inaccurate static analysis, FCEP dynamically corrects the CFG and CG in real time in subsequent steps.
[0043] 2) Build the mapping
[0044] The concolic executor uses the initial input to test a new version of the software. When the path encounters a branch, the executor generates a new path state and notifies the address finder to find the address of the next instruction for the new state in the statically generated CFG. FCEP maps the new state to the instruction address and puts the new state into the candidate list so that it can be used in subsequent path selection. For concolic execution, the program being tested needs to be translated into an intermediate language to be interpreted and executed. If a branch is encountered during execution, it adds the two generated branch states to the execution tree. FCEP constructs the execution tree in the same way as in static analysis, that is, placing the positive branch in the left subtree and the negative branch in the right subtree. Since the positive and negative branches of the state have been adjusted to be consistent with the CFG generated in static analysis when a new state is created, the next instruction address corresponding to each branch can be quickly queried.
[0045] 3) Dynamically correct CFG and CG
[0046] We need to note that since static analysis cannot accurately infer indirect jumps or function pointer calls, there will be underreporting when using static analysis methods to guide concolic execution. Therefore, if FECP encounters indirect jumps or function pointer calls during concolic execution, it will dynamically correct CFG and CG through the address finder to obtain more accurate path information.
[0047] 3.2 Goal-based search strategy
[0048] The executor generates a new state at the location of the conditional branch, and FCEP puts the newly generated new state into the candidate list for subsequent selection. When a path is executed, the selector selects a new state from the candidate list according to the search strategy to continue running the concolic execution. Since the search strategy usually affects the coverage of concolic execution, careful selection of the search strategy can help achieve the desired goal.
[0049] Before the test begins, FCEP has obtained the address range of each function from CG and selects a path marked in CFG that can be executed from the software entry function to the selected core target (i.e., a line in the patch). When the path of the initial state is executed, FCEP will determine whether the next instruction address of the new state in the candidate list hits the target function (i.e., the function where the patch is located), in other words, whether the address is within the range of the target function. If it hits, FCEP will assign the highest priority to all the new states that hit (i.e., set the priority). The search strategy will select a path closest to the core target in the new state with the highest priority to continue running. After the path is executed, it will continue to select the execution path in the new state with the highest priority. If no new state hits the target function, or the new state with the highest priority is fully executed, FCEP will combine CFG and CG to find the upper-level calling function of the target function and confirm whether there is a new state in the candidate list that hits the upper-level calling function. Similarly, FCEP selects a new state closest to the call point in the new state that hits the calling function to continue execution. Note: Except for the new state for hitting the target function, other new states do not have priority. Since previously generated new states have already been confirmed whether they hit the target function or its caller, FCEP prioritizes new states derived from the current running state to confirm whether they hit the target function.
[0050] As we all know, the code addresses of a program are not completely continuous, but the code addresses in the same function of the program are continuous. Therefore, FCEP uses formula D i =|state i _addr-target_addr|Calculate the distance between the new state and the target, and select the new state closest to the target. Where Di represents the distance, state i _addr indicates the next instruction address of the new state, and target_addr indicates the target address. For target_addr, it is first the address of the patch line determined before running the program, and when no new state hits the target function, it is the address of the function call line in the call chain of the target function.
[0051] After that, it will continue to perform all the above steps for the next core target code. The purpose of running all new states that hit the target function (i.e. running all new states with the highest priority) is to test as much code as possible near the patch. Because for the security testing of the patch program, it is usually not enough to focus only on the paths covered by the patch code itself, and the code near the patch is usually associated with the patch, so it is necessary to perform a more comprehensive test on the function where the patch is located.
[0052] 3.3 Examples
[0053] Figure 2 This is an example of the FCEP search strategy. The graph is a combination of the CFG and CG graphs. Assume that the address ranges of each function obtained by FCEP from the CG are FunA (0x00, 0X2F), FunB (0x40, 0x6F), FunA (0xA0, 0xAF). The core target selected in the target function FunC is located at node n. 12 , by selecting a path sequence {n0,n4,n5,n 10 ,n 12}Determine the sequence of function call nodes and their addresses as {n5(0x12)}. The execution tree is empty at the beginning of concolic execution. When FCEP runs the program with the initial input, it is assumed that it corresponds to state state_0, and its sequence is {n0,n1,n2,n7,n8}. At the same time, in concolic execution, this state creates new branch states {state_1,state_2,state_3} in sequence. The address finder searches for the corresponding next instruction addresses (that is, the address of the next block in CFG) for the three new states in CFG. It is assumed that the address of the next instruction of the new state state_1 is 0x08, the address corresponding to state state_2 is 0x06, and the address corresponding to state state_3 is 0x4F. FCEP puts these three new states into the candidate list.
[0054] When the state state_0 is executed, the selector selects a new state from the candidate list. FCEP first determines whether the next instruction address in the three newly generated states hits the target function FunC. If there is one in the target function interval, it selects one away from the core target (n 12 ) is executed by the path closer to the target function. If not, it queries whether there is a state that hits the calling function interval of the target function. As shown in the figure, three states do not hit the target function FunC, but two states {state_1, state_2} hit the upper-level calling function of FunC, and the node that calls the FunC function is n5, whose address is 0x12. FCEP calculates the distance between the addresses of the two states and the address of node n5, that is, D1=4, D2=6. FCEP will select state_1 with a smaller distance as the next execution state.
[0055] When executing in state_1, assume that its execution path is {n0,n4,n5,n 10 ,n 11}, it will generate two new states {state_4, state_5}, whose addresses are 0x1F and 0xAE respectively. FCEP first determines whether the newly generated address hits the target function. At this time, state_5 has entered the target function, so this state is selected as the next execution state. After state_5 is executed, if there is still a state that hits the target function FunC, the state that hits the target function will continue to execute.
[0056] The key points of the present invention mainly include:
[0057] The first key point is to propose address mapping for the new states generated during the concolic test and to propose a method for constructing the address mapping.
[0058] The second key point is to propose a method to modify the CFG and CG produced by static analysis using the dynamic call information in concolic testing.
[0059] The third key point is to propose a target-based search strategy method to search the newly generated branch paths.
[0060] In the address mapping part of the above method, the present invention adopts CFG and CG as the basis for static analysis, and can also express the program structure into other valid forms through other preprocessing methods.
[0061] In the target-based search strategy of the above method, the present invention uses the block address of the program code as the calculation basis and adopts the absolute difference as the basis for path selection. Other effective calculation methods can also be used to use the block address as the basis for path selection.
[0062] Based on the same inventive concept, another embodiment of the present invention provides a software testing device for software update using the method of the present invention, comprising:
[0063] The address mapping module is used to establish the control flow graph CFG and function call graph CG of the new version binary program, mark the possible execution paths of the core target in the CFG, and mark the corresponding function call relationship in the CG; during the concolic execution of the new version binary program, when the execution path encounters a branch, a new state is created for the execution path, and then the address of the next instruction is found for the new state in the CFG, the new state is mapped to the address of the next instruction, and the new state is put into the candidate list;
[0064] The target-based search module is used to select a new state that falls into the target function from the candidate list using a target-based search strategy to continue running the concolic execution after a path is executed.
[0065] Based on the same inventive concept, another embodiment of the present invention provides an electronic device (computer, server, smart phone, etc.), which includes a memory and a processor, the memory stores a computer program, the computer program is configured to be executed by the processor, and the computer program includes instructions for executing each step in the method of the present invention.
[0066] Based on the same inventive concept, another embodiment of the present invention provides a computer-readable storage medium (such as ROM / RAM, disk, CD), which stores a computer program. When the computer program is executed by a computer, it implements the various steps of the method of the present invention.
[0067] The specific embodiments of the present invention disclosed above are intended to help understand the content of the present invention and implement it accordingly. It can be understood by those skilled in the art that various replacements, changes and modifications are possible without departing from the spirit and scope of the present invention. The present invention should not be limited to the contents disclosed in the embodiments of this specification, and the scope of protection of the present invention shall be subject to the scope defined in the claims.
Claims
1. A software testing method for software update, characterized in that: The following steps are involved: Establish a control flow graph CFG and a function call graph CG of the new version of the binary program, mark the possible execution paths of the core target in the control flow graph CFG, and mark the corresponding function call relationship in the function call graph CG; group the patches according to the functions to which the patches belong, and select a row of the patches in each group as the core target, which represents the core part of the function modification; During the concolic execution of the new version of the binary program, when the execution path encounters a branch, a new state is created for the execution path, and then the address of the next instruction is found for the new state in the control flow graph CFG, the new state is mapped to the address of the next instruction, and the new state is put into the candidate list; When a path is executed, a goal-based search strategy is used to select a new state that falls into the target function from the candidate list to continue the concolic execution; The target-based search strategy infers the paths covered by the patch and the related paths of the function where the patch is located, and directs the search to these paths to avoid exploring a large number of redundant paths; The goal-based search strategy includes: When a path is executed, determine whether the next instruction address of the new state in the candidate list hits the target function, that is, the function where the patch is located; If hit, assign the highest priority to all hit new states, select a path closest to the core target in the new state with the highest priority to continue running, and after the path is executed, continue to select the execution path in the new state with the highest priority; If there is no hit, or the highest priority new state is fully executed, then the control flow graph CFG and the function call graph CG are combined to find the upper-level calling function of the target function, and confirm whether there is a new state in the candidate list that hits the upper-level calling function; among the new states that hit the upper-level calling function, a new state closest to the call point is selected to continue execution; Using the formula D i = |state i _addr - target_addr| Calculate the distance between the new state and the target, and select the new state closest to the target, where Di represents the distance, state i _addr The address of the next instruction indicating the new state, target_addr Indicates the target address; target_addr is the address of the patch line determined before running the program. When no new state hits the target function, target_addr It is the address of the function call line in the target function's call chain.
2. The method according to claim 1, characterized in that If an indirect jump or function pointer call is encountered during concolic execution, the control flow graph CFG and function call graph CG are dynamically corrected to obtain accurate path information.
3. The method according to claim 1, characterized in that During concolic execution, if a branch is encountered, the states of the two generated branches are added to the execution tree, and the positive branch is placed in the left subtree and the negative branch is placed in the right subtree. That is, when a new state is created, the positive and negative branches of the state are adjusted to be consistent with the control flow graph CFG generated in the static analysis.
4. A software testing device for software update using the method described in any one of claims 1 to 3, characterized in that: include: The address mapping module is used to establish the control flow graph CFG and function call graph CG of the new version binary program, mark the possible execution paths of the core target in the control flow graph CFG, and mark the corresponding function call relationship in the function call graph CG; during the concolic execution of the new version binary program, when the execution path encounters a branch, create a new state for the execution path, then find the address of the next instruction for the new state in the control flow graph CFG, map the new state to the address of the next instruction, and put the new state into the candidate list; The target-based search module is used to select a new state that falls into the target function from the candidate list using a target-based search strategy to continue running the concolic execution after a path is executed.
5. An electronic device, characterized in that: The invention comprises a memory and a processor, wherein the memory stores a computer program, the computer program is configured to be executed by the processor, and the computer program comprises instructions for executing the method according to any one of claims 1 to 3.
6. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program is executed by a computer, the method described in any one of claims 1 to 3 is implemented.
