Function-level intrinsically secure software development system and compilation and debugging method

Abstract

The present invention belongs to the field of cyberspace security technology, and relates to a function-level intrinsic security software development system and compilation and debugging method. It is constructed based on a dynamic heterogeneous redundant architecture and includes: variants, which complete the business logic in the software project through the execution of variant executable files, wherein the variant executable files are generated through software project configuration files, and each variant executable file contains at least business code for processing business logic and package code for sending and receiving arbitration information. Each calling function in the business code corresponds to a point to be determined, and the package code uses the package function corresponding to the point to be determined to send and receive arbitration information of the point to be determined; an arbiter, which receives the arbitration request sent by the variant package code and performs arbitration processing on the arbitration request; an I / O agent, which processes the variant input and output operations and feeds back the processing results to the arbiter, which distributes them to the corresponding variant. The present invention reduces the user application threshold, can be expanded, and improves the software security protection capability.

Description

Technical Field

[0001] The present invention belongs to the field of cyberspace security technology, and in particular relates to a function-level intrinsic security software development system and a compilation and debugging method. Background Art

[0002] Over the years, countless vulnerabilities have been discovered in computer software. These vulnerabilities, when exploited by hackers, can weaken network defenses and even allow host computers to be compromised. With the rapid development of network technology, the rate of evolution of software vulnerabilities has also shown a significant upward trend. Network and information security, implicated in national security and social stability, presents a new and complex challenge. At the same time, existing security technologies often address software vulnerabilities through patching, but their effectiveness lags far behind the demands of network security.

[0003] To address this issue, the concept of intrinsic security based on mimetic construction has been proposed. This concept differs from traditional cybersecurity thinking and technical approaches. It emphasizes the use of an intrinsic security architecture to defend against cyberattacks, rendering software immune to certain cyberattacks. Several successful applications of intrinsic security technology have been established. However, the current intrinsic security software ecosystem is still immature. Currently, intrinsic security software is largely customized based on specific needs. The intrinsic security team analyzes the specific application and develops interception and adjudication strategies for variant execution, forming both high-level and detailed designs. These designs are then developed, tested, and deployed. Under these circumstances, it is difficult for ordinary users to introduce intrinsic security technology into a specific application, making it difficult to effectively implement intrinsic security technology in general user applications. Summary of the Invention

[0004] To this end, the present invention provides a function-level intrinsically secure software development system and compilation and debugging method, which minimizes the user application threshold by adopting unified specifications and interfaces, allows expansion based on the framework, enhances software security protection capabilities, and facilitates application in actual scenarios.

[0005] According to the design scheme provided by the present invention, a function-level intrinsically secure software development system is provided, which is built based on a dynamic heterogeneous redundant architecture. The development framework includes:

[0006] Variants, which implement the business logic in the software project by executing variant executable files. The variant executable files are generated using the software project configuration file, and each variant executable file contains at least business code for processing the business logic and package code for sending and receiving adjudication information. Each call function in the business code corresponds to a point to be adjudicated, and the package function corresponding to the point to be adjudicated is used to send and receive adjudication information for the point to be adjudicated.

[0007] An arbitrator receives an adjudication request sent by a variant package code and performs adjudication processing on the adjudication request;

[0008] The I / O agent processes the input and output operations of the variant and feeds the processing results back to the arbiter, which distributes them to the corresponding variant;

[0009] Each variant, arbitrator and I / O agent communicates by calling their respective interface functions.

[0010] As the function-level intrinsic security software development system of the present invention, further, in the variant, heterogeneous variant executable files are generated respectively according to a plurality of software project configuration files.

[0011] As a function-level intrinsic security software development system of the present invention, further, in the variant package code, the calling function in the business code module is intercepted, and the calling function and the function-related parameters and return information are sent to the arbitrator for arbitration.

[0012] As a function-level intrinsic security software development system of the present invention, further, in the process of intercepting the function call in the business code module, the variant wrapper code is used to replace the calling function in the business code, wherein the wrapper function code is divided into: I / O function class wrapper code for checking I / O class functions, general check function class wrapper code for checking function specified type parameters and specified type return values, and custom check function class wrapper code for user-defined judgment according to the judgment object.

[0013] Furthermore, the present invention also provides a function-level intrinsically secure software compilation and debugging method. Furthermore, based on the above-mentioned system implementation, the implementation process includes the following contents:

[0014] Debug and execute intrinsically secure software compilers using software debugging methods;

[0015] During program execution, a decision request is sent to the arbitrator based on the point to be decided. The decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided. The arbitrator processes the decision request and sends the decision result to the variant package code module.

[0016] The variant checks the decision processing result fed back. If it is abnormal, the execution is exited. Otherwise, the execution continues until it ends or reaches the next decision point and resends the decision request to the arbitrator.

[0017] Furthermore, the present invention also provides a function-level intrinsically secure software compilation and debugging method, based on the above-mentioned system implementation, the implementation process includes the following contents:

[0018] Compiling the arbiter, the I / O agent, and the variants in sequence; and starting the execution of the arbiter, the I / O agent, and the variants respectively;

[0019] When several variants reach a point to be decided during execution, they send a decision request to the arbitrator, where the decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided;

[0020] The arbiter determines whether all the arbitral requests of the variants have arrived. If not, it continues to wait. Otherwise, the arbiter performs the arbitral processing and feeds back the arbitral processing results to each variant.

[0021] Each variant checks the feedback of the arbitration processing result. If it is abnormal, it will exit the execution. Otherwise, it will continue to execute until the execution ends or reaches the next point to be determined and resend the arbitration request to the arbitrator.

[0022] As a function-level intrinsically secure software development and debugging method of the present invention, the arbiter further processes the arbitration request and determines whether an I / O operation needs to be performed at the arbitration point. If so, it is handed over to the I / O agent. The I / O agent performs a read or write operation based on the I / O operation information and feeds back the operation result to the arbiter. The arbiter performs arbitration processing based on the operation result corresponding to the variant.

[0023] As a function-level intrinsically secure software development and debugging method of the present invention, further, when the pending decision point sends a decision request to the arbitrator, when the variant business code executes to the pending decision point, the execution of the variant business code is suspended; the wrapper function corresponding to the pending decision point in the variant wrapper code is executed, and the wrapper function is used to collect function information in the pending decision point, and the function information is encapsulated into a decision request and sent to the arbitrator.

[0024] As a function-level intrinsic security software development and debugging method of the present invention, further, when the variant checks the feedback decision processing result, first, the variant wraps the decision result returned by the code parsing arbiter and checks whether there is a logical execution exception in the variant. If there is an exception, an error message is printed and execution is exited. Otherwise, the variant continues to execute according to the function return information of the point to be decided.

[0025] Beneficial effects of the present invention:

[0026] In response to the problems of the current immature endogenous security software ecosystem and the great difficulty for ordinary users to introduce endogenous security technology, the present invention utilizes a function-level endogenous security software development framework based on a dynamic heterogeneous redundant architecture to provide the basic functions required for endogenous security applications. Users only need to have a basic understanding of the framework to develop endogenous security applications on this basis. The framework adopts unified specifications and interfaces, which greatly reduces the difficulty for ordinary users to introduce endogenous security technology. At the same time, the framework supports expansion, and users can add customized functions according to actual needs, which has good application prospects. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] Figure 1 This is a flowchart of a method for implementing a function-level intrinsically secure software development system in an embodiment;

[0028] Figure 2 This is a schematic diagram of the overall compilation and debugging process of the intrinsic security software in the embodiment;

[0029] Figure 3 This is a schematic diagram of the process of compiling and debugging the intrinsic security software in the embodiment;

[0030] Figure 4 This is a schematic diagram of the package code variant decision process in the embodiment. DETAILED DESCRIPTION

[0031] In order to make the objectives, technical solutions and advantages of the present invention clearer and more understandable, the present invention is further described in detail below with reference to the accompanying drawings and technical solutions.

[0032] An embodiment of the present invention provides a function-level intrinsically secure software development system, which is built based on a dynamic heterogeneous redundant architecture. The development framework includes:

[0033] Variants, which implement the business logic in the software project by executing variant executable files. The variant executable files are generated using the software project configuration file, and each variant executable file contains at least business code for processing the business logic and package code for sending and receiving adjudication information. Each call function in the business code corresponds to a point to be adjudicated, and the package function corresponding to the point to be adjudicated is used to send and receive adjudication information for the point to be adjudicated.

[0034] An arbitrator receives an adjudication request sent by a variant package code and performs adjudication processing on the adjudication request;

[0035] The I / O agent processes the input and output operations of the variant and feeds the processing results back to the arbiter, which distributes them to the corresponding variant;

[0036] Each variant, arbitrator and I / O agent communicates by calling their respective interface functions.

[0037] See also Figure 1 As shown in the figure, to address the current immaturity of the intrinsically secure software ecosystem and the difficulty of introducing intrinsically secure technologies for ordinary users, a function-level intrinsically secure software development framework based on a dynamic heterogeneous redundant architecture is proposed. Based on this dynamic heterogeneous redundant architecture, the framework consists of variants, an arbiter, and an I / O proxy. Variants can be generally divided into two parts: variant business code and variant wrapper code. The variant business code implements the business logic and is also protected by the framework. The variant wrapper code is responsible for sending variant adjudication requests, receiving variant adjudication results, and related auxiliary operations. The arbiter, the most complex component of the entire framework, is primarily responsible for receiving and processing variant adjudication requests. The specific adjudication content is determined by the granularity required by the variant software, such as the actual parameters and execution results of the adjudication function in function-level adjudication. To implement the adjudicator's adjudication functionality, the arbiter can design a series of auxiliary functions, including arbiter communication and adjudication message encapsulation and parsing. Since multiple variants cannot perform I / O operations simultaneously, the variant's I / O operations are implemented by the I / O proxy. The variant's I / O processing process is as follows: When a variant encounters an I / O operation, the I / O-related information is sent to the arbiter. The arbiter parses the variant's I / O request and assigns the task to the I / O agent. The I / O agent receives the task from the arbiter, performs a read or write operation based on the I / O information, and feeds the I / O operation results back to the arbiter. Finally, the arbiter distributes the I / O operation results to the variant.

[0038] The framework adopts an interface-oriented design, separating function definition and implementation. Built on the mature foundation of a dynamic, heterogeneous, redundant architecture, the overall architecture is fixed. However, functions can be selectively implemented based on various software requirements. Depending on the application, variants can address one or multiple requirements, achieving inherent security through multiple, non-identical variants. Framework design and development teams can initially implement basic functionality and then iterate and upgrade as needed. For general users, the framework may not precisely meet all requirements, so customization is possible. The framework supports multiple communication methods. For example, during the debugging phase, all modules are integrated through function calls for ease of debugging. During deployment, the arbitrator communicates with variants, and with I / O agents, through sockets, message queues, and named pipes. Messages between variants, the arbitrator, and the I / O agent can be encapsulated and parsed using JSON, XML, or custom message formats, with interface functions used to implement data exchange.

[0039] Furthermore, in this embodiment, variants are used to generate heterogeneous variant executable files based on several software project configuration files. These variant executable files are generated through a series of steps, including analysis of software user requirements, outline and detailed design, code implementation, and testing. The source code to executable program undergoes a series of steps, each of which generates a different variant executable file using different configuration parameters. Using these different variant executable files, a dynamic heterogeneous redundancy architecture is applied to an inherently secure software framework, enhancing the security of software applications.

[0040] Furthermore, in this embodiment, the variant wrapper code intercepts function calls in the business code and sends the called function, its associated parameters, and return information to the arbitrator for arbitration. Furthermore, when the variant wrapper code intercepts function calls in the business code module, it replaces the function calls in the business code module with the wrapper function code. The wrapper function code is categorized by the arbitration target into: I / O function wrapper code for checking I / O functions; general check function wrapper code for checking function parameters and return values ​​of specified types; and custom check function wrapper code for user-defined arbitration.

[0041] To reduce the difficulty for ordinary users to introduce inherent security technologies, they focus solely on the variant business code. The variant wrapper code intercepts functions within the variant business code that require adjudication, sends the function along with its parameters, return value, and other necessary information to the adjudicator, and then waits for the adjudicator to return the adjudication result. The variant business code and the variant wrapper code execute serially. The function to be called by the variant business code is replaced by the corresponding wrapper function within the variant wrapper code. The wrapper function actually executes the function. Before the function actually executes, the wrapper function can adjudicate the function's parameters and after the function actually executes, it can adjudicate its execution result. Execution of the variant business code then continues.

[0042] Depending on the adjudication target, variant wrapper codes can be divided into I / O function wrapper codes, general check function wrapper codes, and custom check wrapper codes. I / O function wrapper codes need to be customized for each I / O function; general check function wrapper codes are used to check function parameters and return values ​​of specified types; custom check wrapper codes are used to implement user-defined adjudications.

[0043] Furthermore, based on the above system, an embodiment of the present invention also provides a function-level intrinsically secure software compilation and debugging method, which specifically includes the following contents:

[0044] Debug and execute intrinsically secure software compilers using software debugging methods;

[0045] During program execution, a decision request is sent to the arbitrator based on the point to be decided. The decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided. The arbitrator processes the decision request and sends the decision result to the variant package code module.

[0046] The variant checks the decision processing result fed back. If it is abnormal, the execution is exited. Otherwise, the execution continues until it ends or reaches the next decision point and resends the decision request to the arbitrator.

[0047] When there is only one variant, the execution of the entire intrinsically secure software is logically serial. Therefore, by using function calls to replace inter-process communication between variants, arbiters, and I / O agents, the entire intrinsically secure software can be compiled as a complete, serially executed software, generating a serially executed program that facilitates debugging of the intrinsically secure software.

[0048] During the actual deployment phase, the variant, arbiter, and I / O are compiled and deployed separately. They communicate through sockets, message queues, named pipes, and other methods. These three are essentially three programs. While ensuring smooth communication, they can be deployed in standalone, distributed, or cloud deployment modes to meet the needs of different scenarios.

[0049] In the case of only one variant, the entire code can be compiled into a program that is logically executed serially. In this case, ordinary software debugging methods, such as single-step debugging, can be used to debug the intrinsic security software as a whole, reducing the debugging workload in the case of multiple variants. The typical execution sequence in this case is: the variant starts execution, and when a judgment is encountered, a function call is used to start the arbitrator. The arbitrator processes the judgment request information. If an I / O operation is involved, the I / O agent is called for processing, and the I / O agent is waited for to return the execution result. After receiving the execution result, the execution result is responded to the variant. The variant receives the judgment response and decides whether to continue executing the code. If execution continues, the above process is repeated at the next judgment point, otherwise the program execution is exited. This debugging method can debug a single variant, a partial execution process of the arbitrator, and the I / O agent code.

[0050] Furthermore, based on the above system, the present invention also provides a function-level intrinsically secure software compilation and debugging method, which specifically includes the following contents:

[0051] Compiling the arbiter, the I / O agent, and the variants in sequence; and starting the execution of the arbiter, the I / O agent, and the variants respectively;

[0052] When several variants reach a point to be decided during execution, they send a decision request to the arbitrator, where the decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided;

[0053] The arbiter determines whether all the arbitral requests of the variants have arrived. If not, it continues to wait. Otherwise, the arbiter performs the arbitral processing and feeds back the arbitral processing results to each variant.

[0054] Each variant checks the feedback of the arbitration processing result. If it is abnormal, it will exit the execution. Otherwise, it will continue to execute until the execution ends or reaches the next point to be determined and resend the arbitration request to the arbitrator.

[0055] Furthermore, when the arbiter makes a decision on the decision request, it determines whether the decision point needs to perform an I / O operation. If it needs to be executed, it is handed over to the I / O agent. The I / O agent performs a read or write operation based on the I / O operation information and feeds back the operation result to the arbiter. The arbiter makes a decision based on the operation result corresponding to the variant. In the process of the point to be decided sending the decision request to the arbiter, when the variant business code executes to the point to be decided, the execution of the variant business code is suspended; the package function corresponding to the point to be decided in the variant package code is executed, and the function information in the point to be decided is collected by the package function, and the function information is encapsulated into a decision request and sent to the arbiter. When the variant checks the feedback decision processing result, first, the variant package code parses the decision result returned by the arbiter and checks whether there is a logical execution exception in the variant. If there is an exception, the error message is printed and the execution is exited. Otherwise, the variant continues to execute based on the function return information of the point to be decided.

[0056] A major challenge with intrinsically secure software is debugging. This approach introduces the "one code, two compilations" model. This allows for debugging the majority of the intrinsically secure software code for a single variant using overall compilation. Alternatively, separate compilations can be used to generate executable files for multiple variants, the arbitrator, and the I / O proxy. These three can then be debugged together for multiple variants and deployed separately. Both compilation modes share the majority of the framework code, while each requires a small number of configuration files and auxiliary files. This allows for both overall compilation and debugging, facilitating deployment. The following flowcharts provide a detailed description of each compilation and debugging approach.

[0057] See also Figure 2 The overall compilation and debugging solution shown in the figure specifically includes:

[0058] Step 201: The user uses the configuration file compiled by the intrinsic security software as a whole to compile it into a program, which can be debugged using conventional software debugging methods;

[0059] Step 202: The user executes the program;

[0060] Step 203: The variant calls the arbiter at the decision point (here the decision point is the function to be decided);

[0061] Step 204: The arbiter determines whether an I / O operation needs to be performed;

[0062] Step 205: If the decision requires an I / O operation, it is handed over to the I / O agent for execution;

[0063] Step 206: The arbitrator returns the decision result;

[0064] Step 207: The variant continues to execute. First, the decision result is checked. If the decision result is abnormal, the variant exits execution. Otherwise, the variant continues to execute until the execution ends or reaches the next decision point.

[0065] Compile and run the program separately as follows Figure 3 As shown, specifically including:

[0066] Step 301: The user compiles the arbiter, I / O agent, and several variants respectively;

[0067] Step 302: The user executes the arbiter, the I / O agent, and several variants respectively, wherein the variants are started last;

[0068] Step 303: When several variants reach the decision point, they send decision requests respectively;

[0069] Step 304: The arbiter checks whether all the arbitration requests have arrived. If not, it continues to wait.

[0070] Step 305: The arbiter performs the arbiter and its auxiliary operations;

[0071] Step 306: The arbiter checks whether an I / O operation needs to be performed;

[0072] Step 307: If the decision requires an I / O operation, the arbiter passes it to the I / O agent for completion and receives the result of the I / O operation execution.

[0073] Step 308: The arbitrator returns the decision result to each variant;

[0074] Step 309: The variant continues to execute. First, the decision result is checked. If the decision result is abnormal, the variant exits execution. Otherwise, the variant continues to execute until the execution ends or reaches the next decision point.

[0075] Depending on the object of the decision, variant wrapper codes can be divided into I / O function wrapper codes, general check function wrapper codes, and custom check wrapper codes. I / O function wrapper codes need to be customized for each I / O function; general check function wrapper codes are used to check the function's specified type parameters and specified type return values; custom check wrapper codes are used by users to implement specific decisions. For the solution of using wrapper codes to implement variant decisions, see Figure 4 As shown, it specifically includes the following contents:

[0076] Step 401: Execute variant. This step can be reached by starting variant execution or by step 407.

[0077] Step 402: The variant business code is suspended when it reaches the decision point;

[0078] Step 403: executing the variant wrapping code, i.e. executing the wrapping function corresponding to the function to be determined;

[0079] Step 404: The wrapper function collects information about the function to be decided, including the function name, function parameters, function return value, etc., and encapsulates part of the function information into a decision request according to the needs of the function to be decided, and then sends it to the arbitrator;

[0080] Step 405: The wrapper function waits for the arbitrator to return the decision result and parses it, checking whether the variant has executed abnormally;

[0081] Step 406: If the decision result shows that the variant business code is executed abnormally, then go to step 408; otherwise, go to step 407;

[0082] Step 407: The wrapped function returns the result of executing the function to be judged to the variant. The execution result here is the logical execution result. For example, to judge whether the return value of a function is abnormal, you only need to execute the function and then use the execution result for judgment. In this case, you need to actually execute the function. If a function is an I / O function, the wrapped code does not actually execute the function. It only needs to return the return value in the judgment result to the variant.

[0083] Step 408: Print an error message and exit execution.

[0084] Finally, it should be noted that the above-described embodiments are only specific implementation methods of the present invention, which are used to illustrate the technical solutions of the present invention, rather than to limit them. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the above-described embodiments, those skilled in the art should understand that any person skilled in the art can modify or easily conceive of changes to the technical solutions described in the above-described embodiments within the technical scope disclosed by the present invention, or replace some of the technical features therein with equivalents. Such modifications, changes, or replacements do not deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should be included in the scope of protection of the present invention. Therefore, the scope of protection of the present invention shall be subject to the scope of protection of the claims.

Claims

1. A function-level intrinsically secure software development system, characterized in that: Built on a dynamic heterogeneous redundant architecture, the development system includes: Variants generate heterogeneous variant executable files based on several software project configuration files and execute the variant executable files to complete the business logic in the software project. Each variant executable file contains at least business code for processing the business logic and wrapper code for sending and receiving arbitration information. Each call function in the business code corresponds to a point to be determined, and the wrapper code uses the wrapper function corresponding to the point to be determined to send and receive arbitration information for the point to be determined. The variant wrapper code intercepts function calls in the business code module, replaces the call function in the business code with the wrapper function code, and sends the call function and its related parameters and return information to the arbitrator for arbitration. The wrapper function code is divided into I / O function wrapper code for I / O function checks, general check function wrapper code for checking function parameters and return values ​​of specified types, and custom check function wrapper code for user-defined arbitration based on the arbitration object. An arbitrator receives an adjudication request sent by a variant package code and performs adjudication processing on the adjudication request; The I / O agent processes the input and output operations of the variant and feeds the processing results back to the arbiter, which distributes them to the corresponding variant; Each variant, arbitrator and I / O agent communicates by calling their own interface functions. The variant corresponds to one or more software requirements and achieves inherent security through multiple non-completely consistent variant programs.

2. A function-level intrinsic security software compilation and debugging method, characterized in that: Based on the system implementation described in claim 1, the implementation process includes the following contents: Debug and execute intrinsically secure software compilers using software debugging methods; During program execution, a decision request is sent to the arbitrator based on the point to be decided. The decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided. The arbitrator processes the decision request and sends the decision result to the variant package code module. The variant checks the decision processing result fed back. If it is abnormal, the execution is exited. Otherwise, the execution continues until it ends or reaches the next decision point and resends the decision request to the arbitrator.

3. The function-level intrinsic security software compilation and debugging method according to claim 2, characterized in that: The arbiter processes the arbitration request and determines whether the arbitration point needs to perform an I / O operation. If it needs to be executed, it is handed over to the I / O agent. The I / O agent performs a read or write operation based on the I / O operation information and feeds the operation result back to the arbiter. The arbiter makes a ruling based on the operation result corresponding to the variant.

4. The function-level intrinsic security software compilation and debugging method according to claim 2, characterized in that: During the process of sending a decision request from the pending decision point to the arbitrator, when the variant business code is executed to the pending decision point, the execution of the variant business code is suspended; the package function corresponding to the pending decision point in the variant package code is executed, and the package function is used to collect function information in the pending decision point, and the function information is encapsulated into a decision request and sent to the arbitrator.

5. The function-level intrinsic security software compilation and debugging method according to claim 2, characterized in that: When the variant checks the feedback of the adjudication processing result, first, the variant package code parses the adjudicator's adjudication result and checks whether there is any logical execution exception in the variant. If there is an exception, it prints an error message and exits execution. Otherwise, the variant continues execution according to the function return information of the decision point.

6. A function-level intrinsic security software compilation and debugging method, characterized in that: Based on the system implementation described in claim 1, the implementation process includes the following contents: Compiling the arbiter, the I / O agent, and the variants in sequence; and starting the execution of the arbiter, the I / O agent, and the variants respectively; When several variants reach a point to be decided during execution, they send a decision request to the arbitrator, where the decision request contains at least the function name, function parameters, and return information corresponding to the point to be decided; The arbiter determines whether all the arbitral requests of the variants have arrived. If not, it continues to wait. Otherwise, the arbiter performs the arbitral processing and feeds back the arbitral processing results to each variant. Each variant checks the feedback of the arbitration processing result. If it is abnormal, it will exit the execution. Otherwise, it will continue to execute until the execution ends or reaches the next point to be determined and resend the arbitration request to the arbitrator.

7. The function-level intrinsic security software compilation and debugging method according to claim 6, characterized in that: The arbiter processes the arbitration request and determines whether the arbitration point needs to perform an I / O operation. If so, it is handed over to the I / O agent. The I / O agent performs read or write operations based on the I / O operation information and feeds the operation results back to the arbiter. The arbiter makes a ruling based on the operation results corresponding to the variant.

8. The function-level intrinsic security software compilation and debugging method according to claim 6, characterized in that: During the process of sending a decision request from the pending decision point to the arbitrator, when the variant business code is executed to the pending decision point, the execution of the variant business code is suspended; the package function corresponding to the pending decision point in the variant package code is executed, and the package function is used to collect function information in the pending decision point, and the function information is encapsulated into a decision request and sent to the arbitrator.

9. The function-level intrinsic security software compilation and debugging method according to claim 6, characterized in that: When the variant checks the feedback of the adjudication processing result, first, the variant package code parses the adjudicator's adjudication result and checks whether there is any logical execution exception in the variant. If there is an exception, it prints an error message and exits execution. Otherwise, the variant continues execution according to the function return information of the decision point.

Images