GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method

Abstract

The invention discloses a GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method, and the method specifically comprises the steps: analyzing parts, which are liable to be affected by SDC, in a communication mechanism of a target network, and constructing a fault model facing a low-orbit Internet routing mechanism and causing a soft error by a single event effect; aiming at an embedded program in a target network communication mechanism, extracting the characteristics of an instruction in the program, and evaluating the SDC occurrence probability of the instruction; constructing an instruction SDC vulnerability prediction model ISVPG based on GCN, constructing an instruction dependency graph according to the extracted instruction features and the dependency relationship, and training an instruction SDC vulnerability prediction model based on a graph convolutional neural network; and according to the characteristics of other instruction nodes in the training sample graph, performing prediction by using a GCN-based instruction SDC vulnerability prediction model, and identifying the instruction SDC vulnerability. According to the method, the space-time overhead of prediction can be reduced, the prediction accuracy is improved, guidance is provided for a radiation hardening scheme of a low-orbit internet routing mechanism, and the reliability of the network routing mechanism is improved.

Description

Technical Field

[0001] The present invention belongs to the field of soft reinforcement and trusted network technology, and in particular to a GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method. Background Art

[0002] The low-orbit satellite system operates at an orbital altitude of 500 km to 2000 km. It forms a satellite network through a large number of small satellites, with the advantages of global coverage, low latency and high bandwidth. In the low-orbit satellite network, the routing algorithm is responsible for the forwarding and path selection of data packets to ensure that the data can be efficiently and reliably transmitted from the source node to the destination node. However, the low-orbit satellite network is in the space radiation environment and is susceptible to soft errors caused by high-energy charged particles. Soft errors refer to transient failures caused by radiation in semiconductors and memory chips. Unlike hard failures, soft errors do not cause damage to semiconductors. Therefore, the normal state can be restored by restarting the computer or rewriting the data stored in the memory chip. Soft errors usually manifest as a jump in the logic value of the storage component in the computer. When the soft error affects the hardware components involved in the execution of the current instruction during the program running process, it will cause the execution of this instruction to fail and affect the execution of the program. If soft errors occur during the execution of the routing algorithm, it may have an adverse impact on the service quality and reliability of low-orbit satellite network communications, such as packet loss or incorrect forwarding, routing table update errors, and network performance degradation. Therefore, radiation hardening of routing algorithms in low-orbit satellite networks is crucial.

[0003] According to the impact of soft errors on the operation of routing algorithms in low-orbit satellite networks, they can be divided into crashes, benigns, and silent data corruption (SDC). Among them, crashes refer to soft errors causing crashes, hangs, or other system anomalies during the operation of routing algorithms, and the execution of routing algorithms is terminated. Shielding refers to the shielding of soft errors at the hardware or software level of the low-orbit satellite system during the propagation process, so that the execution of the routing algorithm is not affected in any way and the program execution results are consistent with the fault-free execution results. Crashes or hangs are usually detected and processed by the operating system, while shielded soft errors will not have any impact on the operation of the routing algorithm and do not need to be processed. SDC does not affect the normal execution process of the routing algorithm, but causes data errors, which may cause more serious consequences or even disasters.

[0004] Existing research on SDC vulnerability mainly includes fault injection, fault propagation model and machine learning model. Fault injection (FI) is the most commonly used way to evaluate the SDC vulnerability of instructions. This method uses a large number of random fault injections to count the SDC vulnerability of instructions. Each injection selects a target instruction to flip a bit in the source register or destination register to simulate the occurrence of a single particle effect. Although fault injection at the ISA layer is highly effective, the problem of excessive time overhead has always existed.

[0005] In order to reduce the number of fault injections, researchers have proposed a series of SDC vulnerability prediction methods based on fault propagation models. Li G et al. proposed Trident, an instruction SDC vulnerability prediction method based on a fault propagation model. By analyzing the fault propagation mechanism in instructions at the three levels of static instruction flow, control flow, and memory, the SDC vulnerability of a single instruction or the entire program can be calculated without fault injection; Li G et al. later proposed vTrident to study the impact of different inputs on SDC vulnerability, and found that the differences in fault propagation of instructions under different input conditions and the differences in the number of instruction executions and dynamic executions of instructions jointly affect the final SDC rate, and based on this, proposed improvements to Trident; Zhimin Li et al. evaluated the fault tolerance boundary of instructions by calculating the differences in the execution results of subsequent instructions caused by faulty instructions. SDC vulnerability prediction based on fault propagation models often has insufficient accuracy due to the defects of fault propagation models.

[0006] In recent years, many researchers have used machine learning techniques to predict SDC vulnerabilities. PARIS tested 18 regression models through cross-validation and selected the most accurate regression prediction model for SDC vulnerability prediction; G-SEPM used SVM, Adaboost, decision tree, and random forest methods to classify instruction fault types; Lu Q et al. proposed a decision tree-based SDC vulnerability prediction model SDCTune, which extracts instruction features and uses classification regression trees to predict instruction SDC vulnerabilities; Yang N proposed an instruction SDC vulnerability identification method based on SVM; J. Jiao et al. used graphSage, a graph convolutional neural network, to predict instruction SDC vulnerabilities, and Junchi Ma et al. used graph attention network GAT to predict instruction SDC vulnerabilities. Although existing machine learning-based methods can significantly reduce time overhead, the lack of instruction feature mining and the lack of targeting of routing algorithms limit their prediction accuracy.

[0007] In summary, although the current research on SDC vulnerability has achieved a lot of research results, there are still the following problems that need further study: (1) The time overhead of SDC vulnerability assessment is too large; (2) The accuracy of SDC vulnerability prediction is insufficient; (3) The existing SDC vulnerability prediction lacks specificity for routing algorithms. Summary of the invention

[0008] The purpose of the present invention is to provide a method for constructing a network threat knowledge graph based on SecBABC in order to solve the problems existing in the above-mentioned prior art. The data sources of the method include public vulnerability databases, network threat intelligence and security knowledge of network security blogs, so as to expand the coverage of the network threat knowledge graph. At the same time, named entity recognition and relationship extraction are performed based on the SecBABC model, and entity alignment is performed through the EAABNA algorithm, which can effectively improve the accuracy of knowledge extraction and improve the quality of knowledge graph construction.

[0009] The technical solution to achieve the purpose of the present invention is: on the one hand, a method for predicting the vulnerability of the SDC of the low-orbit Internet routing mechanism based on GCN is provided, and the method comprises the following steps:

[0010] Step 1: According to the operation process of the target low-orbit interconnection network routing mechanism, the main parts susceptible to soft errors and the possible impacts of soft errors are analyzed, and a fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established;

[0011] Step 2: Convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform a fault injection experiment on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0012] Step 3: construct an instruction dependency graph as the input of the graph convolutional neural network; use the graph convolutional neural network to learn the topological structure and feature information between nodes in the instruction dependency graph, and construct and train an instruction SDC vulnerability prediction model based on the graph convolutional neural network;

[0013] Step 4: extract node features of other instructions in the embedded program of the target network communication mechanism, use the instruction SDC vulnerability prediction model based on graph convolutional neural network to predict the SDC vulnerability of the instruction, and identify SDC vulnerable instructions.

[0014] On the other hand, a GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction system is provided, the system comprising:

[0015] The first module is used to analyze the main parts susceptible to soft errors and the possible impacts of soft errors according to the operation process of the target low-orbit interconnection network routing mechanism, and establish a fault model of soft errors caused by single-particle effects in the target low-orbit interconnection network routing mechanism;

[0016] The second module is used to convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform fault injection experiments on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0017] The third module is used to construct an instruction dependency graph as the input of the graph convolutional neural network; the graph convolutional neural network is used to learn the topological structure and feature information between nodes in the instruction dependency graph, and the instruction SDC vulnerability prediction model based on the graph convolutional neural network is constructed and trained;

[0018] The fourth module is used to extract node features of other instructions in the embedded program of the target network communication mechanism, predict the SDC vulnerability of the instruction using the instruction SDC vulnerability prediction model based on the graph convolutional neural network, and identify SDC vulnerable instructions.

[0019] Compared with the prior art, the present invention has the following significant advantages:

[0020] (1) By analyzing the impact of soft errors on the routing mechanism and constructing a fault model of the low-orbit Internet routing mechanism, the proposed SDC vulnerability prediction method is targeted at the embedded programs in the routing mechanism, thereby obtaining a lower prediction error.

[0021] (2) The present invention uses GCN to predict instruction SDC vulnerabilities, and only needs to perform a small amount of initial fault injection to obtain the samples required for model training, effectively avoiding the time overhead required for large-scale fault injection into the program.

[0022] (3) A GCN-based SDC vulnerability prediction method for the low-orbit Internet routing mechanism is proposed, which avoids the large amount of time overhead required by the fault injection method. At the same time, it is targeted at the routing algorithm and can achieve higher prediction accuracy, which can effectively evaluate the SDC vulnerability of the low-orbit Internet routing mechanism.

[0023] The present invention is further described in detail below in conjunction with the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] Figure 1 Schematic diagram of the SDC vulnerability prediction method of the low-orbit interconnection network routing mechanism based on GCN in the present invention.

[0025] Figure 2 An example diagram of an instruction dependency graph extracted in one embodiment.

[0026] Figure 3 The figure is a performance comparison diagram of the present method and other methods in one embodiment.

[0027] Figure 4 FIG. 4 is a graph showing an error reduction curve in one embodiment. DETAILED DESCRIPTION

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

[0029] It should be noted that if there are descriptions involving "first", "second", etc. in the embodiments of the present invention, the descriptions of "first", "second", etc. are only used for descriptive purposes and cannot be understood as indicating or implying their relative importance or implicitly indicating the number of the indicated technical features. Therefore, the features defined as "first" and "second" may explicitly or implicitly include at least one of the features. In addition, the technical solutions between the various embodiments can be combined with each other, but they must be based on the ability of ordinary technicians in the field to implement them. When the combination of technical solutions is 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 the present invention.

[0030] In one embodiment, in combination Figure 1 , a GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is provided, the method comprising the following steps:

[0031] Step 1: According to the operation process of the target low-orbit interconnection network routing mechanism, the main parts susceptible to soft errors and the possible impacts of soft errors are analyzed, and a fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established;

[0032] Step 2: Convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform a fault injection experiment on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0033] Step 3: construct an instruction dependency graph as the input of the graph convolutional neural network; use the graph convolutional neural network to learn the topological structure and feature information between nodes in the instruction dependency graph, and construct and train an instruction SDC vulnerability prediction model based on the graph convolutional neural network;

[0034] Step 4: extract node features of other instructions in the embedded program of the target network communication mechanism, use the instruction SDC vulnerability prediction model based on graph convolutional neural network to predict the SDC vulnerability of the instruction, and identify SDC vulnerable instructions.

[0035] Further, in one of the embodiments, the step 1 of establishing a fault model of a target low-orbit interconnection network routing mechanism caused by a single-particle effect causing a soft error specifically includes:

[0036] Step 1.1, Classification of the impact of soft errors on the routing mechanism: The impact of soft errors that occur during the operation of the routing mechanism is divided into three categories: benign faults (Benign), crashes (Crash) and result errors (SDC). Among them, benign faults (Benign) refer to soft errors that are shielded by hardware during propagation or shielded by the characteristics of the instructions themselves or the logic of the program during the operation of the routing algorithm. At this time, the soft error has no impact on the operation of the program and the results of the program, the routing algorithm runs normally, and the routing table is updated correctly; Crash refers to soft errors that cause the operation of the routing algorithm to trigger an exception, causing the process to be killed by the operating system, or soft errors that change the operation logic of the program, such as an infinite loop or a process blocked on a certain resource that makes the program unable to respond. At this time, the execution of the routing algorithm is abnormal, and the routing table cannot be updated correctly; Result errors (SDC) refer to soft errors that cause errors in the update of the routing table and do not affect the normal operation process of the program, but the result is an error.

[0037] Step 1.2: Routing algorithm execution process division. According to the execution process of the routing algorithm, the routing algorithm is logically divided into the following five stages:

[0038] (1) Neighbor Discovery (ND): A router discovers neighboring routers and establishes neighbor relationships by sending Hello messages.

[0039] (2) Link State Information Exchange (LSIE): After a neighbor relationship is established, a router will periodically send Link State Advertisement (LSA) messages to its neighbor routers. These LSA messages contain the status information of all links connected to the router, including: link cost, status, and destination network information;

[0040] (3) Link State Database Update (LSDU): Each router will update its own Link State Database (LSDB) based on the received LSA message. The Link State Database stores the topology information of the entire network, including the links connected to it and the information of neighboring routers;

[0041] (4) Shortest Path Calculation (SPC): The router uses the Dijkstra shortest path algorithm to calculate the shortest path to all destination networks. It checks the link state information in the link state database and calculates the shortest path and cost to the destination network.

[0042] (5) Routing Table Update (RTU): Finally, each router updates its routing table based on the calculated shortest path information. The routing table contains the next-hop router and outbound interface information to reach each destination network, as well as the corresponding cost.

[0043] Step 1.3, based on the routing algorithm structure and the division of the operation phase, the soft errors and faults caused by single particle effects during the operation of the routing algorithm are modeled, and the faults are described using formula (1):

[0044] Fault = {F feat ,F res |F res ∈{Benign,Crash,Sdc}}#(1)

[0045] Among them, F feat Indicates the characteristics of the fault, describing the specific location of the fault and the characteristics related to the fault location; F res Indicates the results caused by the fault, corresponding to the three possible effects of the soft error on the routing algorithm described in step 1.1; the specific steps of routing algorithm instruction feature extraction are as follows:

[0046] Step 1.3.1: Collect the instruction information of the soft error in the routing algorithm according to formula (2) and extract the fault feature F feat ;

[0047] F feat ={F Pos ,Feat}#(2)

[0048] Among them, F Pos Indicates the specific location where the fault occurs. Feat represents the feature vector of the fault, including position features, instruction features, bit flip features, etc.

[0049] Step 1.3.2: Extract the specific location feature F of the fault from the collected information according to formula (3) Pos ;

[0050] F Pos ={F Phase ,F funcIdx ,F insIdx ,F regIdx ,F bit |F Phase ∈{ND,LSIE,LSDU,SPC,RTU}}#(3)

[0051] Among them, F Phase They represent the routing algorithm stage where the fault occurs, F funcIdx The function index indicating the occurrence of a fault, F insIdx Indicates the instruction index where the fault occurred, F regIdx Indicates the operand index where the fault occurred, F bit Indicates the position of the register where the flipped bit that caused the fault is located.

[0052] Step 1.3.3, construct the fault feature vector Feat according to formula (4);

[0053] Feat={F Pos ,F insStatic ,F insDynRatio ,F insRoute ,F flip |F flip ∈{0,1}}#(4)

[0054] Among them, Feat represents the feature vector of the fault, including the fault location feature F Pos , instruction static feature F insStatic , the ratio of the number of dynamic executions of instructions to the total number of executions F insDynRatio , instruction routing feature F insRoute and the bit-flip feature F flip The bit flip feature indicates that the flip type is "0->1" or "1->0". The instruction routing feature indicates the dependency feature between the instruction and the key data structure of the routing algorithm, including whether it is on the data dependency path of the key data structure and the propagation path length of the instruction to the key data structure;

[0055] Step 1.3.4: Extract the static feature F of the faulty instruction according to formula (5) insStatic ;

[0056] F insStatic ={F opCode ,F dataType ,Fstruct}#(5)

[0057] Among them, F insStatic Indicates the static characteristics of the instruction, including the instruction operation code F opcCode , the data type of the instruction is F dataType , instruction structure feature F struct . Among them, F dataType Indicates that the data type of the instruction is integer (F dataType =0) or floating point type (F dataType =1).

[0058] Step 1.3.5: Extract the type feature F of the faulty instruction according to formula (6) opCode ;

[0059] F opCode ={add,sub,load,mul,icmp,getelementptr,phi,sext,alloca}#(6)

[0060] Step 1.3.6, extract the program structure features of the faulty instruction according to formula (7);

[0061] F struct ={loopDepth,isLoopFactor,isGlobel,isStatic,isParam,isRetVal}#(7)

[0062] Among them, F struct Indicates the structural characteristics of the instruction program, including the loop depth of the instruction, whether it is a loop factor, whether it is a global variable, whether it is a static variable, whether it is a function parameter or return value.

[0063] Step 1.3.7, extract the routing related features of the faulty instruction according to formula (8);

[0064] F insRoute ={F lsa ,F lsdb ,F routeTable ,F Phase #(8)

[0065] Among them, F insRoute Indicates the routing-related features of the instruction, F lsa 、F lsdb 、F routeTable They represent the propagation distances from the soft error instruction to the lsa, lsdb, and routeTable related data structures. The propagation distances are calculated using the number of instructions. Phase Indicates the routing algorithm execution stage where the faulty instruction is located.

[0066] In summary, the fault model can be abstractly expressed as formula (9):

[0067]

[0068] Furthermore, in one embodiment, the characteristics of the instruction in step 2 include a characteristic vector Feat of the instruction, a static characteristic F insStatic 、Type feature F opCode 、Program structure features F struct and routing feature F insRoute ; The dependency relationship between the instructions includes data dependency and control dependency. The data dependency refers to the dependency relationship between the source operands or destination operands of two instructions, and the control dependency refers to the causal relationship between the execution order of two instructions.

[0069] Furthermore, in one embodiment, the process of extracting the features of instructions and the dependencies between instructions in the routing algorithm source program of the target network routing mechanism in step 2 specifically includes:

[0070] Step 2.1, compile the routing algorithm source program in the target network routing mechanism into an intermediate code format to obtain a static instruction sequence as shown in formula (10):

[0071] I={ins1,ins2,…ins N}#(10)

[0072] Among them, ins i represents the i-th static instruction, and N represents the total number of static instructions.

[0073] Step 2.2, for each static instruction ins in the static instruction sequence I in step 2.1 i , i∈{1,2,…N}, extract the instruction feature vector v according to the fault feature described in step 1.2 i , forming the instruction feature matrix V as shown in formula (11):

[0074]

[0075] Step 2.3, extracting the dependencies between the instructions in the static instruction set in step 2.1;

[0076] For any two instructions in the static instruction sequence I i ,ins j ,i,j∈{1,2,…N}, the steps to extract the dependency relationship between them are as follows:

[0077] Step 2.3.1, analyze the instruction ins i and ins jThe dependencies between them include control dependency and data dependency. Control dependency refers to ins i with ins j The execution order of the instructions is adjacent, which can be divided into sequential execution, jump, and function call and return. Data dependency refers to the situation where the instruction ins j The source register is the instruction ins i The destination register can be divided into comparison dependency, value dependency and address dependency according to the instruction type, as shown in formula (12):

[0078] rely ij =<seq,jmp,call,cmp,val,addr> #(12)

[0079] Among them, rely ij Is a bit vector representing the instruction ins i With the command ins j All dependencies between instructions. The first three bits of rely represent control dependencies, where seq represents sequential execution, jmp represents jump execution, and call represents function call or return; the last three bits of rely represent data dependencies, where cmp represents comparison instructions, val represents numerical calculations, and addr represents memory addresses. Each bit corresponds to a dependency, and there may be multiple dependencies between instructions. If there is a dependency corresponding to this bit, then this bit is set to 1. For example, if ins i for ins j The next instruction to be executed is ij The seq position is 1;

[0080] Step 2.3.2, extract the instruction dependency edge edg according to the instruction dependency relationship analyzed in step 2.3.1 ij , forming an edge set E, as shown in equations (13) and (14). If the model input is a homogeneous graph, then there is only one type of edge in the graph. If any two instructions have any dependency relationship in equation (12), there is an undirected edge. If the model input is a heterogeneous graph, then according to the dependency relationship between instructions, ij Extract edges:

[0081]

[0082] E={edg ij |i,j∈{1,2,…N}}#(14)

[0083] Where homoG and heterG represent the type of the instruction dependency graph as a homogeneous graph or a heterogeneous graph, respectively. ij Indicates the command ins i With the command insj The corresponding instruction dependency edge;

[0084] Step 2.4, use the fault injection tool to perform the same number of fault injection experiments on each bit in the register of the instruction in the routing algorithm source program in the target network communication mechanism. According to step 1.1, the fault injection results are divided into three categories as shown in formula (15):

[0085] result={benign,sdc,crash}#(15)

[0086] Among them, result = 0 means that the fault injected into the target instruction did not cause the program to crash or the result to be wrong; result = 1 means that the fault caused the program to get an incorrect result; result = 2 means that the fault caused the program to crash and was detected by the system. Through the statistics of the fault injection results, the instruction ins is calculated according to formula (16) r The SDC probability is:

[0087]

[0088] in, Indicates the command ins i The probability of causing SDC when a unit flip occurs, W i Indicates the register width in the routing mechanism, F j represents the number of fault injections into the jth bit of the register, S j Indicates the number of times the fault injection to the jth bit eventually leads to SDC; the SDC probability set of the target instruction sequence is obtained through the fault injection experiment

[0089] Furthermore, in one of the embodiments, the construction and training of the instruction SDC vulnerability prediction model based on the graph convolutional neural network in step 3 specifically includes:

[0090] Step 3.1, construct the instruction dependency graph and extract the instruction feature matrix V according to the content of step 1 N×d And the instruction dependency matrix E N×N , construct the instruction dependency graph shown in formula (17):

[0091] G=(V N×d ,E N×N )#(17)

[0092] Where N is the number of instructions, d is the number of instruction features, E N×N is the adjacency matrix of the instruction dependency graph. If the instruction ins in the instruction sequence I i and the command ins j If there is a dependency relationship between them, then Ei×j =1, otherwise E i×j =0.

[0093] Step 3.2, partitioning of the instruction dependency graph, randomly partitioning the nodes in the instruction dependency graph into a training set (80%) and a validation set (20%).

[0094] Step 3.3, build a two-layer GCN network, and its layer-by-layer propagation rule is shown in formula (18):

[0095]

[0096] Among them, H l , H l+1 They represent the node embedding values ​​after activation of the lth layer and the l+1th layer, l∈{0,1,2}, and for the initial node features, H 0 =V; represents the nodes plus self-loops in the adjacency matrix, where I represents the identity matrix; is the degree matrix corresponding to the instruction dependency graph, Represents the degree of node i; calculate Get the adjacency matrix after symmetric normalization of the adjacency matrix E; W l Represents the learnable parameter matrix of the l-th layer GCN, right multiplied by H l W l Indicates that the neighbor node features of the instruction are aggregated; σ is the ReLU activation function, as shown in formula (19):

[0097] σ(x)=max(0,x)#(19)

[0098] Step 3.4: A linear layer is used after the GCN layer to predict the SDC vulnerability of the instruction. Its input is the node feature embedding H output by the GCNc layer. 3 , the output is the instruction SDC vulnerability prediction value, and the calculation method is shown in formula (21), where, is the basic block vulnerability prediction value, W and b are the weight and bias of the linear layer respectively:

[0099]

[0100] Finally, the mean absolute error is used to calculate the loss L during model training, as shown in formula (22):

[0101]

[0102] Among them, p i and They represent the vulnerability baseline value and vulnerability prediction value of the i-th instruction respectively.

[0103] In one embodiment, a GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction system is provided, the system comprising:

[0104] The first module is used to analyze the main parts susceptible to soft errors and the possible impacts of soft errors according to the operation process of the target low-orbit interconnection network routing mechanism, and establish a fault model of soft errors caused by single-particle effects in the target low-orbit interconnection network routing mechanism;

[0105] The second module is used to convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform fault injection experiments on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0106] The third module is used to construct an instruction dependency graph as the input of the graph convolutional neural network; the graph convolutional neural network is used to learn the topological structure and feature information between nodes in the instruction dependency graph, and the instruction SDC vulnerability prediction model based on the graph convolutional neural network is constructed and trained;

[0107] The fourth module is used to extract node features of other instructions in the embedded program of the target network communication mechanism, predict the SDC vulnerability of the instruction using the instruction SDC vulnerability prediction model based on the graph convolutional neural network, and identify SDC vulnerable instructions.

[0108] For the specific limitations of the SDC vulnerability prediction system for the low-orbit Internet routing mechanism based on GCN, please refer to the limitations of the SDC vulnerability prediction method for the low-orbit Internet routing mechanism based on GCN mentioned above, which will not be repeated here. Each module in the above-mentioned SDC vulnerability prediction system for the low-orbit Internet routing mechanism based on GCN can be implemented in whole or in part by software, hardware and a combination thereof. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0109] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the following is achieved:

[0110] Step 1: According to the operation process of the target low-orbit interconnection network routing mechanism, the main parts susceptible to soft errors and the possible impacts of soft errors are analyzed, and a fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established;

[0111] Step 2: Convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform a fault injection experiment on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0112] Step 3: construct an instruction dependency graph as the input of the graph convolutional neural network; use the graph convolutional neural network to learn the topological structure and feature information between nodes in the instruction dependency graph, and construct and train an instruction SDC vulnerability prediction model based on the graph convolutional neural network;

[0113] Step 4: extract node features of other instructions in the embedded program of the target network communication mechanism, use the instruction SDC vulnerability prediction model based on graph convolutional neural network to predict the SDC vulnerability of the instruction, and identify SDC vulnerable instructions.

[0114] For the specific limitations of each step, please refer to the limitations of the SDC vulnerability prediction method for the GCN-based low-orbit Internet routing mechanism above, which will not be repeated here.

[0115] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored, and when the computer program is executed by a processor, the computer program implements:

[0116] Step 1: According to the operation process of the target low-orbit interconnection network routing mechanism, the main parts susceptible to soft errors and the possible impacts of soft errors are analyzed, and a fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established;

[0117] Step 2: Convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform a fault injection experiment on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results;

[0118] Step 3: construct an instruction dependency graph as the input of the graph convolutional neural network; use the graph convolutional neural network to learn the topological structure and feature information between nodes in the instruction dependency graph, and construct and train the instruction SDC vulnerability prediction model ISVPG (Instruction SDC Vulnerability Prediction model based on GCN) based on the graph convolutional neural network;

[0119] Step 4: extract node features of other instructions in the embedded program of the target network communication mechanism, use the instruction SDC vulnerability prediction model based on graph convolutional neural network to predict the SDC vulnerability of the instruction, and identify SDC vulnerable instructions.

[0120] For the specific limitations of each step, please refer to the limitations of the SDC vulnerability prediction method for the GCN-based low-orbit Internet routing mechanism above, which will not be repeated here.

[0121] The method of the present invention uses a graph data structure to characterize the routing mechanism source program, such as Figure 2 As shown, the node number represents the instruction number, the arrow between the nodes represents the dependency relationship between the two nodes, and the node color represents the instruction SDC vulnerability value obtained by fault injection for the node.

[0122] MAE (mean absolute error) is used to evaluate the prediction performance of the instruction SDC vulnerability prediction model, and the comparison methods are SDCTune and GLAIVE. The evaluation results are as follows: Figure 3 As shown in Figure 1, it can be seen that the SDC vulnerability prediction performance of the method of the present invention is better than that of the other two methods. The test error of the instruction SDC vulnerability prediction model decreases with the number of iterations as shown in Figure 1. Figure 4 As shown, it can be seen that the model error converges after 200 iterations, and the time overhead required is negligible and much smaller than the fault injection method.

[0123] The method of the present invention constructs a fault model of soft errors caused by single particle effects in the low-orbit Internet routing mechanism to abstractly represent the soft errors occurring in the routing mechanism, uses an instruction dependency graph to characterize the routing mechanism source program, and uses a graph convolutional neural network to learn the node embedding in the instruction dependency graph to predict the SDC vulnerability of the nodes. Compared with other instruction SDC vulnerability prediction methods, this method has low time overhead, high prediction accuracy, and is more targeted at embedded programs in the routing mechanism.

[0124] The above shows and describes the basic principles, main features and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited by the above embodiments, and the above embodiments and descriptions are only for explaining the principles of the present invention. Without departing from the spirit and scope of the present invention, any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method, characterized in that: The method comprises the following steps: Step 1: According to the operation process of the target low-orbit interconnection network routing mechanism, the main parts susceptible to soft errors and the possible impacts of soft errors are analyzed, and a fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established; Step 2: Convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform a fault injection experiment on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results; Step 3: construct an instruction dependency graph as the input of the graph convolutional neural network; use the graph convolutional neural network to learn the topological structure and feature information between nodes in the instruction dependency graph, and construct and train an instruction SDC vulnerability prediction model based on the graph convolutional neural network; Step 4: extract node features of other instructions in the embedded program of the target network communication mechanism, use the instruction SDC vulnerability prediction model based on graph convolutional neural network to predict the SDC vulnerability of the instruction, and identify SDC vulnerable instructions.

2. According to claim 1, the GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is characterized in that: The fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established in step 1, specifically including: Step 1.1, the impact of soft errors that occur during the operation of the routing mechanism is divided into three categories: benign failures (Benign), crashes (Crash), and result errors (SDC); Step 1.2, according to the execution process of the routing algorithm, the routing algorithm is logically divided into the following five stages: (1) Neighborhood establishment, or ND: A router discovers adjacent routers and establishes neighbor relationships by sending Hello messages. (2) Link State Information Exchange (LSIE): After a neighbor relationship is established, a router periodically sends Link State Update (LSA) messages to its neighbor routers. LSA messages contain the status information of all links connected to the router, including the link cost, status, and destination network information. (3) Link State Database Update (LSDU): Each router updates its own Link State Database (LSDB) based on the received LSA message. (4) Shortest Path Calculation or SPC: The router calculates the shortest path to all destination networks by checking the link state information in the link state database and calculating the shortest path and cost to the destination network; (5) Routing table update or RTU: Each router updates its routing table based on the calculated shortest path information; Step 1.3, based on the routing algorithm structure and the division of the operation phase, the soft errors and faults caused by single particle effects during the operation of the routing algorithm are modeled, and the faults are described by the following formula: Fault={F feat ,F res |F res ∈{Benign,Crash,Sdc}} Among them, F feat Indicates the characteristics of the fault, describing the specific location of the fault and the characteristics related to the fault location; F res Indicates the results caused by the failure, corresponding to the three effects in step 1.1; Among them, the specific steps of routing algorithm instruction feature extraction are as follows: Step 1.3.1: Collect the instruction information of the soft error in the routing algorithm and extract the fault feature F according to the following formula: feat ; F feat ={F Pos ,Feat} Among them, F Pos Indicates the specific location where the fault occurs; Feat represents the characteristic vector of the fault; Step 1.3.2: Extract the specific location feature F of the fault from the collected information according to the following formula: Pos ; F Pos ={F Phase ,F funcIdx ,F insIdx ,F regldx ,F bit |F Phase ∈{ND,LSIE,LSDU,SPC,RTU}} Among them, F Phase Indicates the routing algorithm stage where the fault occurs, F funcIdx The function index indicating the occurrence of a fault, F insIdx Indicates the instruction index where the fault occurred, F regIdx Indicates the operand index where the fault occurred, F bit Indicates the position of the flipped bit that caused the fault in the register; Step 1.3.3, construct the fault feature vector Feat according to the following formula; Feat={F Pos ,F insStatic ,F insDynRatio ,F insRoute ,F flip |F flip ∈{0,1}} Among them, Feat represents the feature vector of the fault, including the fault location feature F Pos , instruction static feature F insStatic , the ratio of the number of dynamic executions of instructions to the total number of executions F insDynRatio , instruction routing feature F insRoute and the bit-flip feature F flip ; Its bit flip feature F flip Indicates the flip type is "0->1" or from "1->0"; instruction routing feature F insRoute Represents the dependency characteristics between instructions and key data structures of the routing algorithm; Step 1.3.4: Extract the static feature F of the faulty instruction according to the following formula: insStatic ; F insStatic ={F opCode ,F dataType ,F struct } Among them, F insStatic Represents the static characteristics of the instruction, including the instruction's opcode F opCode , data type F of the instruction dataType The program structure characteristics F of the location of the instruction struct ; Step 1.3.5, extract the operation code F of the faulty instruction according to the following formula opCode ; F opCode ={add,sub,load,mul,icmp,getelementptr,phi,sext,alloca} According to the instruction types in the test program, select add, sub, load, mul, icmp, getelementptr, phi, sext and alloca, a total of 9 instruction types, and set F according to the type of fault instruction. opCode The corresponding position of is 1, and the other positions are 0; Step 1.3.6, extract the program structure feature F of the faulty instruction according to the following formula: struct ; F struct ={loopDepth,isLoopFactor,isGlobel,isStatic,isParam,isRetVal} Among them, F struct Indicates the structural features of the instruction program, including the loop depth loopDepth of the instruction, whether it is a loop factor isLoopFactor, whether it is a global variable isGlobel, whether it is a static variable isStatic, whether it is a function parameter isParam or a return value isRetVal; Step 1.3.7, extract the routing related features of the faulty instruction according to the following formula; F insRoute ={F lsa ,F lsdb ,F routeTable ,F Phase } Among them, F insRoute Indicates the instruction routing characteristics, F lsa 、F lsdb 、F routeTable They represent the propagation distances from the soft error instruction to the key data structures of lsa, lsdb, and routeTable, respectively. Phase Indicates the routing algorithm execution stage where the faulty instruction is located; Step 1.4, in summary, the fault model of the target low-orbit interconnection network routing mechanism caused by single-particle effects is established as follows:

3. According to claim 2, the GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is characterized in that: The dependency characteristics described in step 1.3.3 include whether the instruction is on the data dependency path of the critical data structure and the length of the propagation path from the instruction to the critical data structure.

4. According to claim 2, the GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is characterized in that: The data type F of the instruction in step 1.3.4 dataType Includes: Integer, by F dataType =0 indicates floating point type, represented by F dataType =1 indicates.

5. According to claim 2, the GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is characterized in that: The features of the instruction in step 2 include the feature vector Feat of the instruction, the static feature F insStatic 、Type feature F opCode 、Program structure features F struct and routing feature F insRoute ; The dependency relationship between the instructions includes data dependency and control dependency. The data dependency refers to the dependency relationship between the source operands or destination operands of two instructions, and the control dependency refers to the causal relationship between the execution order of two instructions.

6. According to claim 5, the GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction method is characterized in that: The specific process of extracting the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions in step 2 includes: Step 2.1, compile the routing algorithm source program in the target network routing mechanism into an intermediate code format to obtain a static instruction sequence I as shown below: I={ins1,ins2,…ins N } Among them, ins i represents the i-th static instruction, N represents the total number of static instructions, i∈{1, 2, …N}; Step 2.2, for each static instruction ins in the static instruction sequence I i , extract the feature vector v according to step 1.2 i , forming the instruction feature matrix V as shown below: in, are the specific position features F corresponding to the i-th static instruction Pos , static features, dynamic execution ratio features, instruction routing features, and bit flipping features; Step 2.3, extracting the dependencies between instructions in the static instruction sequence in step 2.1; Step 2.4, use the fault injection tool to perform the same number of fault injection experiments on each bit in the register of the instruction in the routing algorithm source program in the target network communication mechanism, and divide the fault injection results into three categories: result = {Benign, SDC, Crash} Among them, result indicates the fault injection result, Benign indicates benign fault, Crash indicates crash, and SDC indicates result error; Step 2.5, calculate the instruction ins according to the following formula through the fault injection result statistics i The SDC probability is: in, Indicates the command ins i The probability of causing SDC when a unit flip occurs, W i Indicates the register width in the routing mechanism, F j represents the number of fault injections into the jth bit of the register, S j Indicates the number of times the fault injection to the jth bit eventually leads to SDC; the SDC probability set of the target instruction sequence is obtained through the fault injection experiment 7. The method for predicting SDC vulnerability of a low-orbit Internet routing mechanism based on GCN according to claim 6 is characterized in that: In step 2.3, for a static instruction sequence, any two instructions ins i 、ins j The steps to extract dependencies are as follows: Step 2.3.1, analyze the instruction ins i and ins j The dependency relationship between them, i, j∈{1, 2, ...N}, includes control dependency and data dependency; among them, control dependency refers to ins i with ins j The execution order of the instructions is adjacent, which is divided into sequential execution, jump, and function call and return; data dependency refers to the case where the instruction ins j The source register is the instruction ins i The destination register is divided into comparison dependency, value dependency and address dependency according to the instruction type, as shown in the following formula: rely ij =<seq,jmp,call,cmp,val,addr> Among them, rely ij Is a bit vector representing the instruction ins i With the command ins j All dependencies that exist between ij The first three digits in the __register__ represent control dependencies, where seq represents sequential execution, jmp represents jump execution, and call represents function call or return; ij The last three bits in represent data dependencies, where cmp indicates comparison instructions, val indicates numerical calculations, and addr indicates memory addresses. If there is a dependency corresponding to a bit, that bit is set to 1. Step 2.3.2, extract the instruction dependency edges according to the instruction dependency relationship analyzed in step 2.3.1 to form an edge set E, as shown in the following formula; if the input of the model is a homogeneous graph, then there is only one type of edge in the graph, and if any two instructions have any dependency relationship in step 2.3.1, there is an undirected edge; if the model input is a heterogeneous graph, then according to the dependency relationship between instructions rely ij Extract edges: E={edg ij |i,j∈{1,2,…N}} Among them, homoG and heterG respectively indicate that the type of the instruction dependency graph is a homogeneous graph or a heterogeneous graph, edg ij Indicates the command ins i With the command ins j The corresponding instruction dependency edge.

8. The method for predicting SDC vulnerability of a low-orbit Internet routing mechanism based on GCN according to claim 7 is characterized in that: The construction process of the instruction SDC vulnerability prediction model based on graph convolutional neural network in step 3 includes: Step 3.1, according to step 2, extract the instruction feature matrix V N×d And the instruction dependency matrix E N×N , construct the instruction dependency graph shown below: G=(V N×d ,E N×N ) Where N is the number of instructions, d is the number of instruction features, E N×N is the adjacency matrix of the instruction dependency graph. If the static instruction sequence, the instructions in i and the command ins j If there is a dependency relationship between them, then E i×j =1, otherwise E i×j =0; Step 3.2, randomly divide the nodes in the instruction dependency graph into training sets and test sets; Step 3.3, build a two-layer GCN network, and the layer-by-layer propagation rule of its node embedding is as follows: Among them, H l , H l+1 They represent the node embedding values ​​after activation of the lth layer and the l+1th layer, l∈{0, 1, 2}, and for the initial node features, H 0 =V; represents the nodes in the adjacency matrix plus the self-loops, where represents the identity matrix; is the degree matrix corresponding to the instruction dependency graph, Represents the degree of node i; calculate Get the adjacency matrix after symmetric normalization of the adjacency matrix E; W l Represents the learnable parameter matrix of the l-th layer GCN, right multiplied by H l W l Indicates that the neighbor node features of the instruction are aggregated; σ is the ReLU activation function, as shown in the following formula, where x is the function input: σ(x)=max(0,x) Step 3.4: A linear layer is used after the GCN layer to predict the SDC vulnerability of the instruction. Its input is the node feature embedding H output by the GCN layer. 3 , the output is the instruction SDC vulnerability prediction value, which is calculated as follows: in, is the basic block vulnerability prediction value, W and b are the weight and bias of the linear layer respectively.

9. The method for predicting SDC vulnerability of a low-orbit Internet routing mechanism based on GCN according to claim 8 is characterized in that: When training the instruction SDC vulnerability prediction model based on graph convolutional neural network in step 3, the loss L is calculated using the mean absolute error, as shown in the following formula: where pi and They represent the vulnerability baseline value and vulnerability prediction value of the i-th instruction respectively.

10. A GCN-based low-orbit Internet routing mechanism SDC vulnerability prediction system based on the method according to any one of claims 1 to 9, characterized in that: The system comprises: The first module is used to analyze the main parts susceptible to soft errors and the possible impacts of soft errors according to the operation process of the target low-orbit interconnection network routing mechanism, and establish a fault model of soft errors caused by single-particle effects in the target low-orbit interconnection network routing mechanism; The second module is used to convert the routing algorithm source program in the network routing mechanism into an intermediate code form, extract the characteristics of the instructions in the routing algorithm source program of the target network routing mechanism and the dependencies between the instructions; use the fault injection tool to perform fault injection experiments on the instructions in the target low-orbit interconnection network routing program, and count the SDC vulnerabilities of the instructions based on the fault injection results; The third module is used to construct an instruction dependency graph as the input of the graph convolutional neural network; the graph convolutional neural network is used to learn the topological structure and feature information between nodes in the instruction dependency graph, and the instruction SDC vulnerability prediction model based on the graph convolutional neural network is constructed and trained; The fourth module is used to extract node features of other instructions in the embedded program of the target network communication mechanism, predict the SDC vulnerability of the instruction using the instruction SDC vulnerability prediction model based on the graph convolutional neural network, and identify SDC vulnerable instructions.

Images