Monitoring method and system for CGI program of terminal Internet of Things equipment, and medium

Abstract

The invention discloses a monitoring method and system for a CGI program of terminal Internet of Things equipment, and a medium. The method comprises the following steps: constructing a control flow diagram of the CGI program; performing dominating relation analysis on the control flow diagram of the CGI program to extract a key address set of the CGI program; configuring an Internet of Things equipment debugging environment; a CGI (Common Gateway Interface) Wrapper intermediate layer is deployed; comprising the steps that a web configuration file corresponding to the Internet of Things equipment is acquired, the web configuration file is analyzed to replace a CGI program path with a CGI Wrapper script path, so that when a web request is processed, a web server does not call a CGI program any more and directly calls a CGI Wrapper program; after the Internet of Things equipment receives a web request, a CGI Wrapper program starts a CGI program in a debugging mode, and when the CGI Wrapper program runs to any key address, a debugger executes breakpoint response and generates a path discovery event message; and carrying out statistics on key addresses in all the path discovery event messages to obtain path coverage information in the CGI program running process.

Description

Technical Field

[0001] The present invention belongs to the technical field of Internet of Things device security, and in particular relates to a monitoring method, system, and medium for CGI programs of terminal Internet of Things devices. Background Art

[0002] With the rapid development of IoT technology, a vast network of IoT devices has been deployed worldwide. However, device security issues are becoming increasingly prominent, and security vulnerabilities in web management systems have become a primary means of attack against IoT devices. Currently, mainstream web management systems utilize an open-source web server and a CGI binary program architecture customized by device manufacturers. While open-source web servers have been thoroughly verified and demonstrated high security, customized CGI programs, due to a lack of systematic security testing, have become a major security weakness in IoT devices.

[0003] In terms of security testing technology, path coverage-guided gray-box fuzz testing is currently one of the most effective vulnerability detection methods. Its core approach is to use real-time path coverage information from the system under test to guide test data generation and optimize testing effectiveness. However, existing methods for monitoring the operation of CGI programs and collecting path coverage have many limitations. Traditional program monitoring methods rely on software simulation of IoT devices. Device simulation technology is limited by device heterogeneity and system complexity, making it difficult to widely apply. Recently, researchers have proposed program monitoring solutions based on the debugger GDB / gdbserver. However, this solution requires the program under test to be launched with a debugger mounted or dynamically debugged during execution, making it incompatible with the dynamic startup and instantaneous exit characteristics of CGI programs. These technical limitations make existing solutions difficult to meet the real-time monitoring needs of IoT CGI programs. A new operation monitoring method is urgently needed to overcome the technical bottleneck of coverage collection. Summary of the Invention

[0004] The purpose of the present invention is to overcome the deficiencies in the prior art and provide a new method and device for code feature analysis and behavior monitoring of terminal Internet of Things CGI programs.

[0005] In a first aspect, an embodiment of the present invention provides a method for monitoring CGI programs of terminal IoT devices, the method comprising the following steps:

[0006] Construct the control flow graph of CGI program;

[0007] Perform dominance relationship analysis on the control flow graph of CGI program to extract the key address set of CGI program;

[0008] Configure the IoT device debugging environment;

[0009] Deploy the CGI Wrapper middle layer, which includes: obtaining the web configuration file corresponding to the IoT device, parsing the web configuration file to replace the CGI program path with the CGI Wrapper script path, so that when processing web requests, the web server no longer calls the CGI program but directly calls the CGI Wrapper program;

[0010] After receiving a web request, the IoT device starts the CGI program in debug mode through the CGI Wrapper program. When running to any key address, the debugger executes a breakpoint response and generates a path discovery event message. The key addresses in all path discovery event messages are counted to obtain the path coverage information during the CGI program running process.

[0011] In a second aspect, an embodiment of the present invention provides an electronic device, including:

[0012] at least one processor; and

[0013] a memory communicatively connected to the at least one processor; wherein,

[0014] The memory stores one or more computer programs that can be executed by the at least one processor, and the one or more computer programs are executed by the at least one processor so that the at least one processor can execute the above-mentioned monitoring method for CGI programs of terminal Internet of Things devices.

[0015] In a third aspect, an embodiment of the present invention provides a computer-readable storage medium having a computer program stored thereon, which implements the above-mentioned monitoring method for CGI programs of terminal IoT devices when executed by a processor.

[0016] In a fourth aspect, an embodiment of the present invention provides a computer program product, including a computer program / instruction, which, when executed by a processor, implements the above-mentioned monitoring method for CGI programs of terminal Internet of Things devices.

[0017] Compared with the prior art, the present invention has the following beneficial effects:

[0018] This invention provides a monitoring method for CGI programs in terminal IoT devices. This method first parses the CGI program to generate a control flow graph, then performs dominance analysis on the control flow graph to extract a set of key addresses. A CGI wrapper is then deployed between the web server and the CGI program to support operational monitoring of key address locations and path coverage data collection during CGI execution using the GDB / gdbserver debugger. This method is simple to implement, flexible, and requires no source code or simulation. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0020] Figure 1 This is a diagram showing the overall architecture of a method for monitoring CGI programs for terminal IoT devices provided by an embodiment of the present invention;

[0021] Figure 2 This is a flowchart of the CGI program monitoring process after the CGI Wrapper middle layer is deployed according to an embodiment of the present invention;

[0022] Figure 3 is a schematic diagram of an electronic device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0023] The present invention will be further described below with reference to the following examples. The following examples are provided only to facilitate understanding of the present invention. It should be noted that, without departing from the principles of the present invention, a number of improvements and modifications may be made to the present invention by those skilled in the art, and such improvements and modifications fall within the scope of the claims of the present invention.

[0024] In addition, the technical solutions between the various embodiments can be combined with each other, but they must be based on the fact that ordinary technicians in this field can implement them. When the combination of technical solutions is mutually contradictory or cannot be implemented, it should be deemed that such a combination of technical solutions does not exist and is not within the scope of protection required by this application.

[0025] like Figure 1 As shown, an embodiment of the present invention provides a monitoring method for CGI programs of terminal Internet of Things devices, the method comprising the following steps:

[0026] Step S1, constructing a control flow graph of the CGI program.

[0027] Specifically, in this example, a decompiler is used to construct the control flow graph of the CGI program. First, the binwalk tool is used to parse the IoT device firmware and extract the CGI binary program. The Ghidra decompiler tool is then used to reverse analyze the obtained CGI program to construct the complete control flow graph (CFG) of the CGI program. The control flow graph of the CGI program contains the jump relationship and control transfer logic between each basic block during the execution of the CGI binary program, where each basic block corresponds to a unique entry address and exit address.

[0028] Step S2: performing a dominance relationship analysis on the control flow graph of the CGI program to extract a key address set of the CGI program.

[0029] Specifically, the control flow graph of the CGI program is subjected to a Lengauer-Tarjan algorithm to perform a dominance relationship analysis to extract all key address sets of the program. Step S2 includes the following sub-steps:

[0030] Step S201 : Analyze the forward dominating node set and the backward dominating node set of each basic block.

[0031] Furthermore, the forward dominator set (Dominator Set) and the backward dominator set (Post-Dominator Set) of each basic block are calculated.

[0032] A depth-first search is performed on the control flow graph, assigning a depth-first number to each node. A depth-first search tree is constructed, and the parent node of each node in the tree is recorded. Next, starting with the node with the highest depth-first number, the semi-dominator of each node is calculated. A semi-dominator is defined as the node with the lowest depth-first number among all nodes that can be reached from a node's predecessor via a path that does not include that node in the depth-first search tree. Next, based on the information from the semi-dominator, the direct dominator of each node is calculated. Finally, starting from each node, the path of the direct dominators is traversed upwards to construct the forward dominating node set. The backward dominating node set can be calculated by reversing the edges of the control flow graph and repeating the above process.

[0033] Step S202 , performing a criticality determination on each basic block, including: analyzing the forward dominating node set and the backward dominating node set of each basic block, and marking the current basic block as a critical block if and only if there is at least one execution path that must pass through the current basic block.

[0034] The specific determination method is that if the intersection of the forward dominating node set and the backward dominating node set of a basic block only contains the basic block itself, then the basic block is a key block.

[0035] Step S203: Using set difference operation to sort out the forward dominating block and the backward dominating block corresponding to each key block, obtain key address information corresponding to each key block; and merge the key address information corresponding to each key block to obtain the key address set of the CGI program.

[0036] For example, for basic block B, basic block B is considered a critical block if and only if there is at least one execution path that must pass through basic block B. If the forward dominating block of critical block B is A, and its backward dominating blocks are C and D, then a set difference operation is performed to eliminate all dominated blocks, i.e., {full set} - {A, C, D}, thereby retaining the key address information of critical block B. The results of this set difference operation are combined for all key blocks to obtain the final, streamlined set of critical addresses.

[0037] Step S3: Configure the IoT device debugging environment.

[0038] It should be noted that since most IoT devices do not support debugging by default, this example uses two sub-steps: obtaining low-level command execution permissions and deploying debugging support to increase the debugging capabilities of IoT devices. First, the low-level command execution permissions of the IoT device are obtained. Then, based on the obtained permissions, the corresponding gdbserver debugging tool is uploaded and deployed on the device to implement debugging support for the IoT device.

[0039] Specifically, step S3 includes:

[0040] Step S301: Obtaining the underlying command execution permission; including:

[0041] Obtaining an existing vulnerability exploit and running it to obtain the underlying command execution permissions of the IoT device to be tested; including: retrieving the existing vulnerability exploit for the target device based on the exploit-db database, and obtaining the underlying command execution permissions of the test device by running the obtained vulnerability exploit;

[0042] Alternatively, disassemble the mainboard of the IoT device, couple a TTL / UART debug interface to the mainboard of the IoT device, and access a serial terminal through the TTL / UART debug interface to obtain the underlying command execution permission of the IoT device to be tested;

[0043] Alternatively, when the debugging interface is unavailable, remove the flash storage chip of the IoT device and use a programmer to tamper with the system startup process in the flash chip to obtain the underlying command execution permission of the IoT device to be tested; for example, by removing the device and adding a startup command for the telnetd program in the / etc / init.d / rcS file of the flash chip, and then installing the flash chip back into the device and starting it, the device will automatically start the telnetd process. The tester can use the telnet command in the test host to connect to the device through the network and obtain the underlying command execution permission.

[0044] Step S302: Identify the processor architecture of the IoT device and generate a gdbserver executable file corresponding to the processor architecture.

[0045] Specifically, the device's processor architecture (ARM / MIPS / x86, etc.) is identified, a gdbserver executable file for the device's corresponding instruction set is generated using a cross-compilation toolchain, and then deployed to a specified directory on the device's file system via the network. Once this process is complete, a complete remote debugging environment is established for the device under test. Testers can use GDB on the test host and gdbserver deployed on the IoT device to debug programs on the device under test.

[0046] Step S4, deploying the CGI Wrapper middle layer; including: obtaining the web configuration file corresponding to the IoT device, parsing the web configuration file to replace the CGI program path with the CGI Wrapper script path, so that when processing a web request, the web server no longer calls the CGI program, but directly calls the CGI Wrapper program.

[0047] It should be noted that the prior art has proposed a program monitoring solution based on the debugger GDB / gdbserver. This solution requires the program under test to be started in a debugger-mounted manner or to be dynamically debugged during execution. However, when processing web requests, CGI programs are dynamically started by the web server, and the CGI program exits immediately after the end of the run. Therefore, the program monitoring solution based on the debugger in the current prior art cannot be directly applied to CGI programs. However, it can be noted that although the CGI program is dynamically called and started by the web server, the configuration file of the web server specifies in detail the path of the CGI program, as well as the calling method and other specifications. Therefore, this example proposes a CGI debugging middle-layer deployment based on intelligent configuration redirection, which can realize the universal modification of the CGI program startup method and expand the debugger-based program monitoring solution to CGI programs.

[0048] Specifically, step S4 includes:

[0049] Step S401: Obtain a web configuration file corresponding to the IoT device.

[0050] Specifically, the web service process is first determined based on the common port number (80 / 443) of the web service. Specifically, commands such as netstat and lsof are executed in the IoT device to determine the process number corresponding to the port number 80 / 443; then the specific web server configuration file path is determined through the relevant process information. The detailed startup command information of the process is stored in the " / proc / process number / " directory of the IoT device system. By analyzing the detailed startup command of the process or the corresponding program, the name and path of the web configuration file (such as / etc / lighttpd.conf) can be obtained.

[0051] In step S402, the large language model is fine-tuned according to the web server configuration specification file, the web configuration file corresponding to the IoT device is input into the large language model for parsing, and a modification script is output; the modification script replaces the CGI program path with the CGI Wrapper script path, so that when processing a web request, the web server no longer calls the CGI program, but directly calls the CGI Wrapper program.

[0052] Furthermore, this example parses the web configuration files in IoT devices and provides modification strategies based on the large language model and various web configuration file syntax specifications, so as to deploy the CGIWrapper middle layer between the web server and the CGI program to achieve the purpose of dynamic debugging and activation of the CGI program.

[0053] It should be noted that the web servers used in the Internet of Things are different. Common ones include Lighttpd, ApacheHttpd, Nginx, etc. Different web servers use different web configuration file formats. Although there are specific specifications for various web configurations, if you rely on manual understanding of each web configuration file, the modification efficiency is relatively low.

[0054] Therefore, this example leverages the large language model's ability to understand configuration file specifications. It uses this large language model and various web server configuration specification files to build an agent. By setting corresponding prompts, the agent automatically generates an adaptive web configuration modification script upon receiving a specific IoT device web configuration file. This modification script replaces the original CGI program path with the CGI wrapper script path. After completing this step, when processing web requests, the web server no longer calls the CGI program, but instead directly calls the CGI wrapper program.

[0055] Step S403 , activating CGI dynamic debugging, so that the CGI Wrapper program starts the CGI program in debugging mode each time it is called, to support dynamic monitoring of the CGI program based on the debugger.

[0056] Furthermore, the following logic is implemented in the CGI Wrapper: when called, it identifies the specific CGI program called each time and starts the target CGI program in gdbserver mode. The actual execution command is "gdbserver:PORT ORIGINAL_CGI_PATH", where PORT is dynamically allocated according to the device port usage and ORIGINAL_CGI_PATH is the absolute path of the original CGI program.

[0057] In step S5, after receiving the web request, the IoT device starts the CGI program in debug mode through the CGI Wrapper program. When the program reaches any key address, the debugger executes a breakpoint response and generates a path discovery event message. The key addresses in all path discovery event messages are counted to obtain the path coverage information during the CGI program execution.

[0058] Specifically, if Figure 2 As shown, step S5 includes:

[0059] Step S501: Establish a remote debugging session channel, and establish a network connection with the gdbserver instance of the IoT device through the gdb client.

[0060] Step S502: convert the key address set into memory addresses through address relocation, and deploy breakpoints in batches.

[0061] In step S503, after the breakpoints are deployed, upon receiving a web request, the IoT device starts the CGI program in debug mode using the CGI Wrapper program. When the CGI program reaches any key address, the debugger captures the SIGTRAP signal, executes the breakpoint response, and generates a path discovery event message. The path discovery event message includes a timestamp, register values, call stack contents, and an environment variable snapshot.

[0062] Step S504: dynamically remove the triggered breakpoints and continue to execute the CGI program until the current CGI program ends. Count the key addresses in all path discovery event messages to obtain path coverage information during the CGI program execution.

[0063] In summary, this invention provides a monitoring method for CGI programs in terminal IoT devices. This method first parses the CGI program to generate a control flow graph, then performs dominance analysis on the control flow graph to extract a set of key addresses. A CGI wrapper is then deployed between the web server and the CGI program to support runtime monitoring of key address locations and path coverage data collection using the GDB / gdbserver debugger. This method is simple to implement, flexible, and requires no source code or simulation.

[0064] On the other hand, an embodiment of the present invention further provides a monitoring system for CGI programs of terminal IoT devices, the system comprising the following steps:

[0065] Control flow graph construction module, used to construct the control flow graph of CGI program;

[0066] A key address set extraction module is used to perform a dominance relationship analysis on the control flow graph of the CGI program to extract the key address set of the CGI program;

[0067] Device debugging environment configuration module, used to configure the debugging environment of IoT devices;

[0068] The CGI Wrapper middle-layer deployment module is used to deploy the CGI Wrapper middle-layer. This module includes: obtaining the web configuration file corresponding to the IoT device, parsing the web configuration file to replace the CGI program path with the CGI Wrapper script path, so that when processing a web request, the web server no longer calls the CGI program but directly calls the CGI Wrapper program;

[0069] The CGI program operation monitoring module is used when an IoT device receives a web request. The CGI Wrapper program starts the CGI program in debug mode. When it runs to any key address, the debugger executes a breakpoint response and generates a path discovery event message. The key addresses in all path discovery event messages are counted to obtain path coverage information during the CGI program operation.

[0070] Regarding the system in the above embodiment, the specific manner in which each module performs operations has been described in detail in the embodiment of the method, and will not be elaborated here.

[0071] For the system embodiment, since it basically corresponds to the method embodiment, the relevant parts can be referred to the partial description of the method embodiment. The system embodiment described above is only illustrative, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules can be selected according to actual needs to achieve the purpose of the solution of this application. A person of ordinary skill in the art can understand and implement it without paying any creative work.

[0072] Accordingly, the present application also provides an electronic device, comprising: one or more processors; a memory for storing one or more programs; when the one or more programs are executed by the one or more processors, the one or more processors implement the above-mentioned monitoring method for CGI programs of terminal IoT devices. Figure 3 As shown in the figure, a hardware structure diagram of any device with data processing capability is provided for the monitoring method of CGI program for terminal Internet of Things devices provided by the embodiment of the present invention. Figure 3 In addition to the processor, memory, and network interface shown, any device with data processing capabilities in which the apparatus in the embodiment is located may also include other hardware, generally based on the actual functions of the device with data processing capabilities, which will not be described in detail.

[0073] Accordingly, the present application also provides a computer-readable storage medium having computer instructions stored thereon, which, when executed by a processor, implement the monitoring method for the CGI program of the terminal Internet of Things device as described above. The computer-readable storage medium can be the internal storage unit of any device with data processing capabilities described in any of the aforementioned embodiments, such as a hard disk or memory. The computer-readable storage medium can also be an external storage device, such as a plug-in hard disk, a smart memory card (Smart Media Card, SMC), an SD card, a flash card (Flash Card), etc. equipped on the device. Furthermore, the computer-readable storage medium can also include both the internal storage unit and the external storage device of any device with data processing capabilities. The computer-readable storage medium is used to store the computer program and other programs and data required by any device with data processing capabilities, and can also be used to temporarily store data that has been output or is to be output.

[0074] The above embodiments are intended only to illustrate the design concepts and features of the present invention. Their purpose is to enable those skilled in the art to understand the contents of the present invention and implement them accordingly. The scope of protection of the present invention is not limited to the above embodiments. Therefore, any equivalent changes or modifications made based on the principles and design concepts disclosed in the present invention are within the scope of protection of the present invention.

Claims

1. A monitoring method for CGI programs of terminal Internet of Things devices, characterized in that: The method comprises the following steps: Construct the control flow graph of CGI program; Perform dominance relationship analysis on the control flow graph of CGI program to extract the key address set of CGI program; Configure the IoT device debugging environment; Deploy the CGI Wrapper middle layer, which includes: obtaining the web configuration file corresponding to the IoT device, parsing the web configuration file to replace the CGI program path with the CGI Wrapper script path, so that when processing web requests, the web server no longer calls the CGI program but directly calls the CGI Wrapper program; After receiving a web request, the IoT device starts the CGI program in debug mode through the CGI Wrapper program. When running to any key address, the debugger executes a breakpoint response and generates a path discovery event message. The key addresses in all path discovery event messages are counted to obtain the path coverage information during the CGI program running process.

2. A monitoring method for CGI programs of terminal Internet of Things devices according to claim 1, characterized in that: The control flow graph of the CGI program includes the jump relationship and control transfer logic between all basic blocks during the execution of the CGI program, and each basic block corresponds to a unique entry address and exit address.

3. A monitoring method for CGI programs of terminal Internet of Things devices according to claim 1, characterized in that: The process of extracting the key address set of the CGI program includes: Analyze the forward dominating node set and backward dominating node set of each basic block; Performing a criticality determination on each basic block, including: analyzing the forward dominating node set and the backward dominating node set of each basic block, and marking the current basic block as a critical block if and only if there is at least one execution path that must pass through the current basic block; The forward dominating block and the backward dominating block corresponding to each key block are sorted out by set difference operation to obtain key address information corresponding to each key block; the key address information corresponding to each key block is merged to obtain the key address set of the CGI program.

4. A monitoring method for CGI programs of terminal Internet of Things devices according to claim 1, characterized in that: The process of configuring the IoT device debugging environment includes: Obtain the underlying command execution permission; including: Obtain existing vulnerability exploits and run them to gain the underlying command execution permissions of the IoT device to be tested. Alternatively, disassemble the mainboard of the IoT device, couple a TTL / UART debug interface to the mainboard of the IoT device, and access a serial terminal through the TTL / UART debug interface to obtain the underlying command execution permission of the IoT device to be tested; Alternatively, when the debug interface is unavailable, remove the flash memory chip of the IoT device and use a programmer to tamper with the system startup process in the flash chip to obtain the underlying command execution permission of the IoT device under test; Identify the processor architecture of the IoT device and generate a gdbserver executable file corresponding to the processor architecture.

5. A monitoring method for CGI programs of terminal Internet of Things devices according to claim 1, characterized in that: The process of deploying the CGI Wrapper middle layer includes: Get the web configuration file corresponding to the IoT device; Fine-tune the large language model according to the web server configuration specification file, input the web configuration file corresponding to the IoT device into the large language model for parsing, and output a modification script; the modification script replaces the CGI program path with the CGIWrapper script path, so that when processing a web request, the web server no longer calls the CGI program but directly calls the CGIWrapper program; Activate CGI dynamic debugging so that the CGI Wrapper program starts the CGI program in debug mode each time it is called, to support dynamic monitoring of CGI programs based on the debugger.

6. A monitoring method for CGI programs of terminal Internet of Things devices according to claim 1, characterized in that: The process of obtaining path coverage information during the running of a CGI program includes: Establish a remote debugging session channel and establish a network connection between the gdb client and the gdbserver instance of the IoT device; Convert key address sets into memory addresses through address relocation and deploy breakpoints in batches; After the breakpoint is deployed, the IoT device receives a web request and the CGI wrapper program starts the CGI program in debug mode. When the CGI program reaches any key address, the debugger executes the breakpoint response and generates a path discovery event message. The path discovery event message includes a timestamp, register values, call stack content, and an environment variable snapshot. Remove the triggered breakpoints and continue executing the CGI program until the current CGI program ends. Count the key addresses in all path discovery event messages to obtain the path coverage information during the CGI program execution.

7. A monitoring system for CGI programs of terminal IoT devices, characterized in that: The system comprises the following steps: Control flow graph construction module, used to construct the control flow graph of CGI program; A key address set extraction module is used to perform a dominance relationship analysis on the control flow graph of the CGI program to extract the key address set of the CGI program; Device debugging environment configuration module, used to configure the debugging environment of IoT devices; The CGI Wrapper middle-layer deployment module is used to deploy the CGI Wrapper middle-layer. This module includes: obtaining the web configuration file corresponding to the IoT device, parsing the web configuration file to replace the CGI program path with the CGI Wrapper script path, so that when processing a web request, the web server no longer calls the CGI program but directly calls the CGI Wrapper program; The CGI program operation monitoring module is used when an IoT device receives a web request. The CGI Wrapper program starts the CGI program in debug mode. When it runs to any key address, the debugger executes a breakpoint response and generates a path discovery event message. The key addresses in all path discovery event messages are counted to obtain path coverage information during the CGI program operation.

8. An electronic device, characterized in that: include: at least one processor; as well as a memory communicatively connected to the at least one processor; wherein, The memory stores one or more computer programs that can be executed by the at least one processor, and the one or more computer programs are executed by the at least one processor so that the at least one processor can execute the monitoring method for CGI programs for terminal Internet of Things devices as described in any one of claims 1 to 6.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the computer program implements the monitoring method for a CGI program for a terminal Internet of Things device according to any one of claims 1 to 6.

10. A computer program product comprising a computer program / instructions, characterized in that When the computer program / instruction is executed by a processor, the monitoring method for the CGI program of the terminal Internet of Things device described in any one of claims 1 to 6 is implemented.

Images