CN108733528B - Constraint-based system fault injection method - Google Patents
Constraint-based system fault injection method Download PDFInfo
- Publication number
- CN108733528B CN108733528B CN201810366804.1A CN201810366804A CN108733528B CN 108733528 B CN108733528 B CN 108733528B CN 201810366804 A CN201810366804 A CN 201810366804A CN 108733528 B CN108733528 B CN 108733528B
- Authority
- CN
- China
- Prior art keywords
- constraint
- fault
- negation
- data
- normal form
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000002347 injection Methods 0.000 title claims abstract description 50
- 239000007924 injection Substances 0.000 title claims abstract description 50
- 238000000034 method Methods 0.000 title claims abstract description 39
- 238000012360 testing method Methods 0.000 claims abstract description 25
- 230000009467 reduction Effects 0.000 claims abstract description 6
- 238000001514 detection method Methods 0.000 claims abstract description 4
- 239000000243 solution Substances 0.000 claims description 21
- 230000002159 abnormal effect Effects 0.000 claims description 11
- 230000008569 process Effects 0.000 claims description 5
- 238000006467 substitution reaction Methods 0.000 claims 1
- 230000007547 defect Effects 0.000 abstract description 5
- 238000005516 engineering process Methods 0.000 abstract description 5
- 230000009286 beneficial effect Effects 0.000 abstract description 2
- 230000008030 elimination Effects 0.000 abstract 1
- 238000003379 elimination reaction Methods 0.000 abstract 1
- 238000010586 diagram Methods 0.000 description 4
- 235000019580 granularity Nutrition 0.000 description 4
- 235000002020 sage Nutrition 0.000 description 3
- 239000008186 active pharmaceutical agent Substances 0.000 description 2
- 238000000354 decomposition reaction Methods 0.000 description 2
- 238000002474 experimental method Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000005856 abnormality Effects 0.000 description 1
- 238000010521 absorption reaction Methods 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000011156 evaluation Methods 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000002040 relaxant effect Effects 0.000 description 1
- 230000033772 system development Effects 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/26—Functional testing
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Test And Diagnosis Of Digital Computers (AREA)
Abstract
The invention discloses a system fault injection method based on constraint. Dividing constraints into atomic condition and conjunctive normal form clause layers according to atomic condition negation and conjunctive normal form clause negation strategies, and solving a group of negative forms of the reduction constraints on the layers to serve as a basis for generating fault data; replacing constraint variables in the constraint after negation by using normal input combination, then gradually carrying out relaxation replacement on the constraint variables, and finding out minimum variation fault data which is the minimum in the number of the relaxation variables and is closest to the real condition through constraint solving operation; and (3) performing fault injection on the system to be tested by using the minimum variation fault data as test input, and obtaining a fault injection result. By adopting a new fault injection technology, the invention generates more real and more sufficient fault data, enhances the error detection capability of fault injection, and simultaneously, the fault close to the normal state is also beneficial to the repair and defect elimination of testers.
Description
Technical Field
The invention belongs to the technical field of computer system development, and particularly relates to a system fault injection method based on constraint.
Background
Fault injection is a system reliability (dependency) verification technology, and the reliability of a system is detected by deliberately introducing a fault into a system to be verified in an experiment, and detecting and observing the system behavior after the fault is introduced. The existing fault injection mode is generally to inject abnormal data and abnormal code. The former, e.g. e.jeong, etc., generates abnormal data according to the fault model, and injects the abnormal data into the system by means of message interception, etc.; natella et al, for example, inject an exception code at the source code layer or the binary layer to indirectly generate a fault state, thereby achieving the purpose of fault injection.
In terms of fault data injection, some methods generate hardware or communication faults such as bit flipping, byte modification, etc. as proposed by j.h.barton et al, and message loss, message repetition, message head-to-tail swapping, message delay, etc. as proposed by s.han et al. Other methods generate software faults, including pattern-based fault generation methods, data type-based fault generation methods, grammar-based fault generation approaches, and the like. Pattern-based generation faults are generated from empirical fault patterns, such as generating null pointers or erroneous function return codes, to detect the behavior of the target system. And grouping the data according to the data types based on the generation mode of the data types, and then selecting typical abnormal values, such as boundary values of the types, for fault injection. Describing the input grammar structure based on the grammar generation mode, and then generating data in an abnormal format based on the grammar for injection. Johansson et al and Winter et al have also investigated combinations of multiple injection methods to inject multiple errors simultaneously to enhance the ability of fault injection to discover errors. The method can generally generate data with obviously abnormal formats, ranges and the like, but is difficult to generate data with good formats, is not logically in a reasonable fault state, and has large limitation on the application range. In reality, many of the concealed errors are due to structurally sound, but logically unreasonable error conditions, and to reveal these errors, fault injection techniques with logical anomaly data generation capability must be employed.
Constraint-based fault injection provides an opportunity for the generation of logical anomaly data. The SAGE tool of Godefroid et al uses white-box symbolic execution to derive path constraints for a given program path, and then negates predicates in the path constraints to generate new test inputs. The method can generate logically unreasonable fault data relative to the constraint conditions, but under a black box test scenario, it is difficult to know which parts of the constraint conditions correspond to judgment predicates on program paths, so the constraint negation method in SAGE is not suitable for the black box test scenario. On the other hand, the SAGE method obtains a brand-new input data combination through constraint solving for testing, the generated fault data cannot be guaranteed to be close to a real situation, and the fault injection defect detection capability cannot be guaranteed.
Disclosure of Invention
In order to solve the technical problems in the background art, the present invention aims to provide a system fault injection method based on constraints, which derives a group of fault data with good coverage sufficiency and high authenticity based on protocol constraints, thereby effectively detecting the reliability defects of the system.
In order to achieve the technical purpose, the technical scheme of the invention is as follows:
a constraint-based system fault injection method comprises the following steps:
(1) dividing constraints into atomic condition and conjunctive normal form clause layers according to atomic condition negation and conjunctive normal form clause negation strategies, and solving a group of negative forms of the reduction constraints on the layers to serve as a basis for generating fault data;
(2) firstly, replacing constraint variables in the constraint after negation by using normal input combination, then gradually carrying out relaxation replacement on the constraint variables, and finding out minimum variation fault data which has the least number of the relaxation variables and is closest to the real condition through constraint solving operation;
(3) and (3) performing fault injection on the system to be tested by using the minimum variation fault data as test input, and obtaining a fault injection result.
Further, in step (1), the atomic conditional negation strategy comprises the following steps:
firstly, judging whether the input protocol constraint is an atom constraint, and if the input protocol constraint is the atom constraint, directly returning to the negation of the constraint; and if not, negating operators of the top-level logical operator of the input protocol constraint one by one, replacing the original operator with a negated result, and adding the result into the fault constraint set.
Further, in step (1), the conjunctive normal form clause negation strategy includes the following steps:
firstly, decomposing input protocol constraints into a plurality of conjunctive normal form clauses according to conjunction operation to form a normal form clause set;
and traversing the normal form clause set obtained in the last step, replacing the normal form clause with the negation of the normal form clause in the constraint conjunctive normal form expression to obtain fault constraint, and adding the fault constraint into the fault constraint set.
Further, in the step (2), firstly, completely setting the fault data as a normal data combination, then canceling the value assignment of a variable in the normal data, taking the cancelled variable as a candidate variant variable, performing constraint solving detection on the variant variable, detecting whether a solution meeting the constraint after negation can be found, and if the solution can be found, forming the minimum variant fault data by the combination of the solution of the variant variable and other non-variant parts; if not, then the other variables in the inverted constraint are gradually replaced with slack until a solution is obtained.
Further, in the step (3), a fault injection process intercepts a specific software internal or external interface, and then the fault data obtained in the step (2) is sent to a corresponding interface to realize fault injection; and checking the fault tolerance of the system to be tested by observing whether the system to be tested is abnormal after the fault is injected.
Adopt the beneficial effect that above-mentioned technical scheme brought:
the invention divides and negates the constraint with different granularities, further derives the logically unreasonable fault data with different coverage degrees, has higher fault injection test coverage rate, and can more fully detect the fault tolerance of the system to the logic fault. In the generation process of the test data, the test data is generated in a mode of minimum variation instead of directly solving the constraint, so that the generated fault data is ensured to be as close to the original normal data as possible, and the fault data close to the normal data is more likely to occur in a real system, so that the reliability defect of the system can be effectively detected. Fault data that is close to true can also make faults caused by fault injection easier to debug.
Drawings
FIG. 1 is a flow chart of the present invention;
FIG. 2 is a diagram of a constraint negation strategy at different granularities;
fig. 3 is a schematic diagram of the generation of minimal variant fault data.
Detailed Description
The technical scheme of the invention is explained in detail in the following with the accompanying drawings.
A constraint-based system fault injection method is shown in FIG. 1 and includes the following steps.
(1) And (5) negating the specification constraint. And dividing constraints into atomic condition and conjunctive normal form clause levels according to atomic condition negation and conjunctive normal form negation strategies, and solving a group of negative forms of the reduction constraints on the levels to serve as the basis of fault data generation.
(2) And generating tiny variation fault data. Firstly, replacing constraint variables in the constraint after negation by using normal input combination, then gradually carrying out relaxation replacement on the constraint variables, and finding out fault data which is the least in the number of the relaxation variables and is closest to the real condition through constraint solving operation.
(3) Fault injection is performed. And using the test data generated in the steps as test input to carry out fault injection on the system to be tested and obtain a fault injection result.
The constraint division in the step (1) means that the constraints are divided into different layers according to the requirements of a test coverage system in the test process, and the negation operation is performed on the constraints on the divided layers to obtain the negation form of the whole specification constraint. The specific division and negation strategy comprises dividing into atomic conditions for negation, and dividing constraints into conjunctive normal forms for negation. Wherein the atomic condition is a constraint that division can not be performed any more, and each sub-formula of the conjunctive normal form can not be performed conjunctive decomposition any more. The division of different levels corresponds to different test coverage requirements, wherein the atomic coverage and the conjunctive normal form sub-coverage have higher test coverage.
And (3) generating the minimum variation fault data in the step (2), firstly, completely setting the fault data as a normal data combination, wherein the normal data can be obtained by monitoring the system to be tested. Then, the value assignment of one variable in the normal data is cancelled, and the cancelled assigned variable is used as a candidate variant variable. And (4) for the variant variable, carrying out constraint solving to detect whether a solution meeting the constraint after inversion can be found, wherein if the solution can be found, the combination of the solution of the variant variable and other non-variant parts is fault data forming the abnormity. If a satisfactory solution cannot be found, the other variables in the inverted constraint are gradually replaced by relaxation until a solution is obtained. This solution, i.e., the fault data that is closest to the normally executed data, has a higher probability of occurring in a real system with which fault injection testing is performed than with abnormal data that is unlikely to occur in a real system, is more capable of discovering reliability defects.
The fault injection in the step (3) can be realized by technologies such as message interception, API hooking and the like.
How to implement the above technical solution will be further described below.
First stage (constraint reversal)
And (4) negating the given reduction constraint according to strategies with different granularities to obtain a fault constraint set for generating fault data. Each inverted constraint is a negative of the original specification constraint, and if the constraints are satisfied, the original specification constraint must take a value of false, indicating that the data combination satisfying the inverted constraint corresponds to logically unreasonable fault data. Because the inverted constraint represents fault data, it is a model representation of the fault data, and is also referred to as a fault constraint. For a given reduction constraint, there are a number of negation strategies to get its different negation forms. The existing black box fault injection test mainly carries out constraint integral negation, namely negation operation is added before constraint to obtain a negative form of constraint, the mode cannot ensure that the constraint after negation covers various possible fault conditions, and the fault injection coverage rate is low. The invention newly provides two negation strategies of atomic constraint negation and conjunctive normal form clause negation, which can realize higher test coverage. FIG. 2 is a schematic diagram of a constraint negation strategy for different granularities.
1) Atomic constraint negation
A reduced constraint is typically formed by concatenating multiple sets of non-decomposable internal constraints through conjunction, disjunction or negation of logical operators. These non-resolvable constraints, which do not contain any logical operators, are called atomic constraints. Atomic constraint negation is mainly performed on constraint conditions at the atomic constraint level. Simply negating the atomic constraint cannot guarantee that when the constraint is satisfied after negation, the corresponding input data is certain logically unreasonable fault data, and in addition, the variable information contained in the atomic constraint is less and cannot be used for constructing finished fault input. Therefore, the method guarantees that the original protocol constraint cannot be met and the integrity of the generated fault data is guaranteed when the constraint after negation can be met by negation of atomic constraint and then negative combination of an integral constraint. Algorithm 1 gives a recursive processing algorithm for atomic constraint inversion.
The algorithm firstly judges whether the input constraint is an atomic constraint, and if the input constraint is the atomic constraint, the negation of the constraint is directly returned. Otherwise, each operator of the top-level logic operator of the input constraint is inverted one by one, the inverted result is used for replacing the original operator, and the result is added into the fault constraint set serving as the result. The specific steps of the operation of the input constraint non-atomic constraint are firstly to obtain a top-level operation object set of an input constraint C; then, traversing the operation objects in the set, taking the sub-constraints corresponding to the objects as input, and recursively using an atomic constraint inversion algorithm to obtain a sub-fault constraint set corresponding to the sub-constraints; traversing the sub-fault constraint set, replacing the corresponding sub-constraints in the input constraint C with the constraints in the sub-fault constraint set to obtain new constraints, performing conjunction on the obtained constraints and negation of the input constraint C to obtain fault constraints, and adding the fault constraints into the fault constraint set.
2) Conjunctive normal form clause negation
And the conjunctive normal form clause negation strategy negating each conjunctive normal form clause of the original protocol constraint to obtain a negative form of the original constraint. Is provided with C1,C2,…,CnIf the sentence is a conjunctive normal form clause of constraint C, then C ═ C1∧C2∧…∧CnIn which C isi(1. ltoreq. i.ltoreq.k) is an atom constraint or constant (e.g. P or
P) is extracted. Negation of a conjunctive normal form clause of constraint C, i.e. a clause C of conjunctive normal form of constraint CiBy its negation form
CiAnd (6) replacing. Algorithm 2 gives a conjunctive normal form clause negation algorithm.
The first step is as follows: and decomposing the input protocol constraint into a plurality of conjunctive normal form clauses according to the conjunction operation to form a normal form clause set. For example, if C { (pq) × R, the conjunctive normal form subset obtained after decomposition is { (pq), R }. Since the purpose of obtaining the conjunctive normal form is to ensure that the original constraint is effectively divided for generating the fault input, the method does not adopt a Tseitin method introducing a large number of temporary variables to change the conjunctive normal form, but performs the conjunctive normal form transformation based on the De Morgan law, the absorption law and the distribution law.
The second step is that: and traversing the normal clauses to obtain the negation. Traversing the normal form clause set obtained in the last step, in a constraint conjunctive normal form expression, using negation of the normal form clause to replace the normal form clause to obtain fault constraint, and adding the fault constraint into the fault constraint set. For example, the result of negating C ═ Q ^ R is
The method obtains the fault constraint in a mode of replacing the paradigm clause instead of directly taking the negation form of the paradigm clause as the fault constraint. Although the latter can also derive fault data, it cannot ensure that other input limits except for the normal form clause are kept unchanged as much as possible, so that the generated fault data may have overlarge difference with the original normal data and poor fault authenticity.
Second stage (Generation of minimal variation fault data)
The minimum variation fault is generated on the basis of original normal test data, and minimum variation is introduced, so that the varied fault data can enable fault constraint (negative form of original protocol constraint) to be satisfied on one hand and represent logically unreasonable values; and on the other hand, the fault data is made to be as close as possible to the original normal data, so that the injected fault state is ensured to be close to the abnormality which can occur in the real situation.
The invention adopts a method of gradually relaxing the constraint variable to generate fault data. The algorithm begins by first defining the value of each constraint variable in the fault constraint as the normal test data value. Normal values do not satisfy the fault constraints, and therefore, the constraints on the constraint variables need to be gradually relaxed until the fault constraints can obtain satisfiable solutions, namely, minimal variant faults. Algorithm 3 gives a specific fault data generation algorithm. FIG. 3 is a schematic diagram of a fault data generation method.
The algorithm first assumes a constrained variable set V of initial relaxationrelaxAnd if the fault is empty, limiting each constraint variable to the original value assignment A, solving the fault constraint by using a constraint solver, and checking whether a solution exists. If the solution exists, the solution is the minimum variation fault, and the algorithm can return after the solution is obtained.
If the last step can not solve the minimum variation fault, further performing variable relaxation. Selecting a new variable in the variable assignment A to add to the relaxed variable set VrelaxThe fault constraint and the new slack variable set are recursively substituted as parameters into the algorithm to calculate whether fault data can be generated with the new slack variable set. If a non-empty failure data set F' can be generated, the resulting data is merged into the final failure data set F, thereby yielding a minimal variant failure set.
Third stage (fault injection implementation)
The invention generates the fault data with high coverage and strong authenticity through the steps, and after the fault data is obtained, the fault injection is implemented by utilizing the existing technologies of message interception, API hook and the like. The fault injection process intercepts a specific software internal or external interface, and then sends the fault data generated by the invention to the corresponding interface, so that the fault injection can be realized. By observing whether the tested system is down or not after the fault is injected, the fault tolerance of the tested system can be examined.
To demonstrate the superiority of the present invention, we performed experiments on 16 benchmark programs (see Table 1) in the GNU Coreutils-6.11 dataset. By comparing the similarity of the fault data obtained by adopting the technology of generating the extremely small variation fault data with the original normal data on the input level, whether the fault data obtained by the method has better authenticity can be verified. By comparing the statement and branch coverage which can be achieved by the test data obtained by adopting two new strategies of atomic condition negation and conjunctive normal form negation with the test data obtained by adopting the traditional integral negation strategy, whether the invention can realize higher fault injection test coverage by a fine-grained negation strategy can be verified.
Table 2 shows the similarity of the abnormal data obtained by generating the minimal variant fault data to the original normal data in the input layer under different negation strategies. Wherein, CON, CNF and WHOLE respectively represent fault data generation under three negation strategies of atom constraint negation, conjunctive normal form clause negation and constraint integral negation. The generation of fault data with minimal variation is indicated by the min subscript. In terms of atomic constraint negation, using minimal variation on 14 subjects generated failure data closer to normal. In the aspect of negation of conjunctive normal form clauses, fault data closer to normal values can be generated in all experimental objects by using a minimum variation method. In terms of the overall inversion of the constraint, except for the split program, the fault data generated by using the minimal variation method has obviously higher similarity with the normal data. Therefore, for more than 90% of experimental objects, the fault data closer to the original input can be generated by using a method with little variation, and the obtained data has higher authenticity.
Table 3 shows the Statement Coverage (SC) and Branch Coverage (BC) achieved by fault injection for each subject under different strategies. WHOLEcon、WHOLEcnfThe representation inverts the constraint ensemble and generates a failure data set of a size consistent with the CON and CNF policies. In the aspect of statement coverage, the atomic constraint inverse proportion conjunctive norm clauses on 15 experimental objects achieve higher coverage rate, and compared with the integral constraint negation, the atomic constraint negation all obtains better coverage. Paradigm clauseNegation gave better coverage over 15 subjects than constrained global negation. In the aspect of branch coverage, similar results to statement coverage can be obtained. Therefore, the fine-grained constraint negation strategy can achieve higher fault injection test coverage than the existing constraint integral negation strategy.
TABLE 1
| Procedure for measuring the movement of a moving object | Description of the invention | Code line |
| base64 | Encrypting/decrypting data and outputting to a standard output | 3989 |
| chcon | Changing file security context | 4343 |
| chgrp | Changing ownership of a group | 4278 |
| comm | Comparing two sorted files line by line | 3997 |
| cut | Parts are deleted from each line of the file. | 4195 |
| dircolors | ls color setting | 4093 |
| expand | Converting tab to space | 3916 |
| expr | Expression evaluation | 9565 |
| fold | Wrapping each input row in a specified width | 3891 |
| mknod | Special files of blocks or characters are set. | 3840 |
| paste | Merging files | 3837 |
| pathchk | It is checked whether the file name is valid or portable. | 3857 |
| printf | The program is executed through entries in the mailcap file. | 4251 |
| split | File splitting | 4428 |
| sum | The checksum counts blocks in the file. | 4068 |
| tsort | Performing topological ordering | 3856 |
TABLE 2
| Procedure for measuring the movement of a moving object | CONmin | CON | CNFmin | CNF | WHOLEmin | WHOLE |
| base64 | 0.45 | 0.33 | 0.26 | 0.06 | 0.76 | 0.05 |
| chcon | 0.49 | 0.35 | 0.36 | 0.24 | 0.82 | 0.07 |
| chgrp | 0.61 | 0.39 | 0.40 | 0.29 | 0.77 | 0.05 |
| comm | 0.52 | 0.41 | 0.39 | 0.30 | 0.89 | 0.05 |
| cut | 0.52 | 0.48 | 0.25 | 0.22 | 0.74 | 0.07 |
| dircolors | 0.52 | 0.42 | 0.56 | 0.53 | 0.70 | 0.06 |
| expand | 0.42 | 0.42 | 0.34 | 0.06 | 0.85 | 0.05 |
| expr | 0.58 | 0.30 | 0.25 | 0.15 | 0.61 | 0.04 |
| fold | 0.32 | 0.32 | 0.29 | 0.25 | 0.86 | 0.10 |
| mknod | 0.48 | 0.41 | 0.42 | 0.41 | 0.66 | 0.06 |
| paste | 0.50 | 0.52 | 0.29 | 0.24 | 0.80 | 0.06 |
| pathchk | 0.40 | 0.30 | 0.13 | 0.00 | 0.78 | 0.04 |
| printf | 0.62 | 0.42 | 0.44 | 0.20 | 0.62 | 0.04 |
| split | 0.26 | 0.26 | 0.24 | 0.23 | 0.18 | 0.23 |
| sum | 0.45 | 0.35 | 0.38 | 0.09 | 0.69 | 0.06 |
| tsort | 0.72 | 0.63 | 0.31 | 0.00 | 0.80 | 0.04 |
| Average | 0.49 | 0.39 | 0.33 | 0.20 | 0.72 | 0.07 |
TABLE 3
The embodiments are only for illustrating the technical idea of the present invention, and the technical idea of the present invention is not limited thereto, and any modifications made on the basis of the technical scheme according to the technical idea of the present invention fall within the scope of the present invention.
Claims (5)
1. A system fault injection method based on constraint is characterized by comprising the following steps:
(1) dividing constraints into atomic condition and conjunctive normal form clause layers according to atomic condition negation and conjunctive normal form clause negation strategies, and solving a group of negative forms of the reduction constraints on the layers to serve as a basis for generating fault data;
(2) firstly, replacing constraint variables in the constraint after negation by using normal input combination, then gradually carrying out relaxation replacement on the constraint variables, and finding out minimum variation fault data which has the least number of the relaxation variables and is closest to the real condition through constraint solving operation;
(3) and (3) performing fault injection on the system to be tested by using the minimum variation fault data as test input, and obtaining a fault injection result.
2. The constraint-based system fault injection method according to claim 1, wherein in step (1), the atomic conditional negation strategy comprises the following steps:
firstly, judging whether the input protocol constraint is an atom constraint, and if the input protocol constraint is the atom constraint, directly returning to the negation of the constraint; and if not, negating operators of the top-level logical operator of the input protocol constraint one by one, replacing the original operator with a negated result, and adding the result into the fault constraint set.
3. The constraint-based system fault injection method according to claim 1, wherein in step (1), the conjunctive normal form clause negation strategy comprises the following steps:
firstly, decomposing input protocol constraints into a plurality of conjunctive normal form clauses according to conjunction operation to form a normal form clause set;
and traversing the normal form clause set obtained in the last step, in a constraint conjunctive normal form expression, using a negative substitution normal form clause of the normal form clause to obtain fault constraint, and adding the fault constraint into the fault constraint set.
4. The method according to claim 1, wherein in step (2), the fault data is completely set as a normal data combination, and then the assignment of a variable in the normal data is cancelled, the cancelled variable is used as a candidate variant variable, the variant variable is subjected to constraint solution detection, whether a solution satisfying the constraint after the negation can be found is detected, and if the solution can be found, the combination of the solution of the variant variable and other non-variant parts forms the minimum variant fault data; if not, then the other variables in the inverted constraint are gradually replaced with slack until a solution is obtained.
5. The constraint-based system fault injection method according to claim 1, wherein in step (3), a fault injection process intercepts a specific software internal or external interface, and then sends the minimal variation fault data obtained in step (2) to a corresponding interface to realize fault injection; and checking the fault tolerance of the system to be tested by observing whether the system to be tested is abnormal after the fault is injected.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810366804.1A CN108733528B (en) | 2018-04-23 | 2018-04-23 | Constraint-based system fault injection method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810366804.1A CN108733528B (en) | 2018-04-23 | 2018-04-23 | Constraint-based system fault injection method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108733528A CN108733528A (en) | 2018-11-02 |
| CN108733528B true CN108733528B (en) | 2020-07-07 |
Family
ID=63939721
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810366804.1A Active CN108733528B (en) | 2018-04-23 | 2018-04-23 | Constraint-based system fault injection method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108733528B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110658796B (en) * | 2019-10-10 | 2020-11-17 | 江苏亨通工控安全研究院有限公司 | Method for identifying industrial control network key component |
| CN115062566B (en) * | 2022-06-21 | 2023-06-27 | 深圳国微芯科技有限公司 | Method for simplifying circuit containing X value, verification method and storage medium |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8555234B2 (en) * | 2009-09-03 | 2013-10-08 | International Business Machines Corporation | Verification of soft error resilience |
| CN104536877B (en) * | 2014-11-28 | 2017-09-12 | 江苏苏测软件检测技术有限公司 | A kind of test data generating method based on mixed strategy |
| CN107807860B (en) * | 2017-10-12 | 2020-10-27 | 国网湖南综合能源服务有限公司 | Power failure analysis method and system based on matrix decomposition |
| CN107609325A (en) * | 2017-10-18 | 2018-01-19 | 中国航空无线电电子研究所 | The method that fault tree based on SAT solves minimal cut set |
-
2018
- 2018-04-23 CN CN201810366804.1A patent/CN108733528B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN108733528A (en) | 2018-11-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109426722B (en) | SQL injection defect detection method, system, equipment and storage medium | |
| Gabel et al. | Symbolic mining of temporal specifications | |
| CN107368417B (en) | Testing method of vulnerability mining technology testing model | |
| Beschastnikh et al. | Leveraging existing instrumentation to automatically infer invariant-constrained models | |
| Tian et al. | Automatically diagnosing and repairing error handling bugs in C | |
| Yasuoka et al. | Quantitative information flow-verification hardness and possibilities | |
| US10606570B2 (en) | Representing software with an abstract code graph | |
| Bonakdarpour et al. | The complexity of monitoring hyperproperties | |
| Christ et al. | Flow-sensitive fault localization | |
| Wotawa et al. | Automated debugging based on a constraint model of the program and a test case | |
| Nica et al. | On the use of mutations and testing for debugging | |
| Heo et al. | Continuously reasoning about programs using differential bayesian inference | |
| Almaghairbe et al. | Separating passing and failing test executions by clustering anomalies | |
| CN108733528B (en) | Constraint-based system fault injection method | |
| Vanciu et al. | Hidden dependencies in software systems | |
| Jimenez et al. | Software vulnerabilities, prevention and detection methods: A review1 | |
| Pinconschi et al. | A comparative study of automatic program repair techniques for security vulnerabilities | |
| Diaz et al. | Structural testing for communication events into loops of message‐passing parallel programs | |
| Kiesl et al. | Local redundancy in SAT: generalizations of blocked clauses | |
| Gargantini | Using model checking to generate fault detecting tests | |
| Paul et al. | Redefinition of fault classes in logic expressions | |
| Salamah et al. | Using pairwise testing to verify automatically-generated formal specifications | |
| Campos et al. | Encoding test requirements as constraints for test suite minimization | |
| Aribi et al. | Multiple fault localization using constraint programming and pattern mining | |
| Cruz-Filipe et al. | Formally proving the boolean triples conjecture |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |