CN114510414A - Method and system for formalized verification of intelligent contract functional attribute based on symbolic execution - Google Patents
Method and system for formalized verification of intelligent contract functional attribute based on symbolic execution Download PDFInfo
- Publication number
- CN114510414A CN114510414A CN202210047615.4A CN202210047615A CN114510414A CN 114510414 A CN114510414 A CN 114510414A CN 202210047615 A CN202210047615 A CN 202210047615A CN 114510414 A CN114510414 A CN 114510414A
- Authority
- CN
- China
- Prior art keywords
- attribute
- contract
- module
- state
- abstract
- 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.)
- Granted
Links
- 238000012795 verification Methods 0.000 title claims abstract description 50
- 238000000034 method Methods 0.000 title claims abstract description 28
- 238000004458 analytical method Methods 0.000 claims abstract description 13
- 238000006243 chemical reaction Methods 0.000 claims description 11
- 241000282326 Felis catus Species 0.000 claims description 6
- 230000008676 import Effects 0.000 claims description 5
- 238000010276 construction Methods 0.000 claims description 4
- 238000013507 mapping Methods 0.000 claims description 4
- 239000007787 solid Substances 0.000 claims description 4
- 238000012544 monitoring process Methods 0.000 claims description 3
- 230000009466 transformation Effects 0.000 claims description 2
- 230000001939 inductive effect Effects 0.000 abstract description 5
- 238000007781 pre-processing Methods 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 230000006698 induction Effects 0.000 description 2
- 238000012552 review Methods 0.000 description 2
- NLOALSPYZIIXEO-UHFFFAOYSA-N 2-benzoyloxyethyl-[1-[3-(trifluoromethyl)phenyl]propan-2-yl]azanium;chloride Chemical compound Cl.C=1C=CC=CC=1C(=O)OCCNC(C)CC1=CC=CC(C(F)(F)F)=C1 NLOALSPYZIIXEO-UHFFFAOYSA-N 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000010998 test method 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/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3624—Software debugging by performing operations on the source code, e.g. via a compiler
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3604—Software analysis for verifying properties of programs
- G06F11/3608—Software analysis for verifying properties of programs using formal methods, e.g. model checking, abstract interpretation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a method and a system for formalized verification of intelligent contract functional attributes based on symbolic execution, which convert the proof of self-defined functional attributes into reachability verification through contract attribute analysis, and provide a new way for formalized verification by utilizing symbolic execution automation. The invention can automatically carry out formalized verification on the intelligent contract function attribute and output the counterexample of the non-conforming attribute, and can effectively improve the efficiency of symbol execution reachability verification by combining the inductive verification and the iteration fixed point method through the pretreatment of the contract attribute.
Description
Technical Field
The invention relates to the technical field of computer security, in particular to a method and a system for formally verifying intelligent contract function attributes based on symbolic execution.
Background
An intelligent contract is a computer transaction agreement that automatically enforces contract terms without the need for an intermediary, self-verification. The characteristics of decentralized block chain technology, data tamper resistance and the like solve the trust problem of the intelligent contract, so that the intelligent contract is more suitable for being realized on the block chain. Intelligent contracts, as a computer program that can automatically execute contract terms, have high requirements for correctness and other attributes, and need to avoid grammatical and semantic errors as much as possible to ensure the property security of users. Current auditing practices typically detect two types of problems: 1. general security errors such as reentry and overflow; 2. custom functional attributes such as "the sum of deposits never exceeds the balance of the contract" and "the sum of tokens does not change". The former is mainly detected by an automatic test method, and the latter needs a formalization method for verification.
The essence of the formalization method is a technology for describing the attributes of a target software system based on a mathematic method, and is suitable for specification, development and verification of computer software and hardware systems. Formal verification is to determine the program specification and code behavior by using a static analysis method based on mathematical transformation, such as verifying the security attributes of a program from protocol conventions, which is a verification method with the highest security level at present. Due to the lack of automatic verification tools, the current verification work needs to be performed by using a heavyweight interactive theorem proving program, which needs a great amount of manual and professional knowledge, so that the auditing process is expensive and time-consuming, developers and auditing communities rarely adopt the method, and only a few intelligent contract projects are formally verified so far.
Disclosure of Invention
In order to overcome the defects of the prior art, the invention provides a method and a system for formally verifying the functional attribute of an intelligent contract based on symbolic execution.
The technical scheme provided by the invention is as follows: a method for formalizing and verifying intelligent contract function attribute based on symbol execution comprises the steps that firstly, a contract auditor formalizes a custom function attribute into attribute assertion (the attribute assertion adopts a syntax form the same as that of the entity, and additionally adds time attribute operators such as Once and Always), then the attribute assertion is abstracted to try generalizable verification through symbol execution, and if the attribute assertion has generalizable property, the generalized verification can be directly proved; and if the attribute assertions can be successfully derived, the attribute assertions are proved, otherwise, counter-example output is tried to be constructed. The technical scheme mainly comprises four stages: preprocessing stage, induction proving stage, iteration fixed point stage and attribute verification stage. Wherein:
the preprocessing stage performs the following steps:
step 1, receiving one or more contracts C1，C2…CmAnd inputting a series of custom attribute assertions phi1，φ2…φnThe attribute assertion is equivalently transformed into □ phi1’，□φ2’…□φn' form, wherein □ phii' representing attribute assertion phii' always true, m, n, i represent natural numbers.
Step 2, merging a series of input contracts into a contract C0。
Step 3, adding new attribute variables at the corresponding positions of the contracts according to the attribute assertions, and inserting monitoring codes to obtain instrumentation contracts CφContaining the function { f }1，f2…fkWhere k represents a natural number.
Step 4, according to the pile inserting contract CφAnd equivalent transformed attribute assertion □ phi1’，□φ2’…□φn' resolving the required abstract state a.
The inductive proving phase performs the following steps:
step 5, the contract will run in the following loop form, without regard to invoking other external contracts within the contract:
therefore, firstly, the inductive verification is considered, namely, for an attribute needing verification, the phi' is asserted, and the initialized abstract state alpha is constructed by initinitChecking at αinitWhether the following attribute assertion holds. If yes, go to step 6, otherwise, enter the pile-inserting contract CφUnsatisfying an attribute assertion φ', i.e. attesting to an input contract C1，C2…CmNot satisfying the attribute asserts phi.
Step 6, the initialized abstract state alpha is processedinitConversion to an initial set of symbol states S0{s10，s20…sm0}。
Step 7, taking each state in the initial symbol state set as an initial state, executing the function fiObtaining a symbol state set Si{s1i，s2i…smiAnd converted into an abstract state set Ai{α1i，α2i…αmi}。
Step 8, if the initial symbol state set S generated by phi' is asserted for a certain attribute0Respectively execute { f1，f2…fkThe resulting set of symbol states SiAnd its corresponding abstract state set AiIf both phi ' are still true, then phi ' is the generalizable proof attribute assertion and phi ' is always true, i.e. the input contract C is proved1，C2…CmThe satisfied attribute asserts phi. If not, go to step 9.
The iteration fixed point stage executes the following steps:
step 9, according to the initialized abstract state alpha constructed in the step 5initInitializing reachable abstract state set reach (C)φ)0＝{αinit}。
Step 10, executing once while loop in symbol mode, calling fiAnd calculating the exact symbolic state s after the transaction has ended, s being in fact a different path constraint p1 { [ nu ] p2 { [ nu ] … } { [ nu ] p }kAll possibilities of (1), including s1，s2…sk。
Step 11, according to the precise symbol state s1，s2…skCalculating an abstract State α1，α2…αmSince different symbol states may get the same abstract state, k ≧ m.
Step 12, abstract state alpha is converted into abstract state1，α2…αmJoining reachable Abstract State set reach (C)φ)0Get a set of reachable abstract states reach (C)φ)1And repeating the steps 10 and 11. Since the abstract state field is limited, the final reach (C)φ) Must reach a stationary point reach (C)φ)i+1＝reach(Cφ)i。
The attribute verification phase performs the following steps:
step 13, according to the reachable abstract state set, the indefinite point reach (C)φ)fixVerifying whether attribute assertion phi' is satisfied, and if so, proving the contract CφSatisfying the attribute assertion φ', equivalently validating the input contract C1，C2…CmThe property is satisfied and if not, step 14 is entered.
Step 14, trying to review the recorded path information executed by the symbol according to the symbol state corresponding to the abstract state, trying to construct a counter-example { (user, func, args)1，(user,func,args)2…(user,func,args)nAnd output, proving the input contract C1，C2…CmNot satisfying the attribute asserts phi.
The invention realizes a system for formalizing and verifying the intelligent contract function attribute based on symbol execution, which comprises: the system comprises a contract attribute analysis subsystem, a symbol execution subsystem and an abstract verification subsystem; wherein:
the contract attribute analysis subsystem comprises a contract merging module and an attribute analysis module. The contract merging module is used for merging a plurality of contracts into one contract, and according to the syntax of the solid, the contracts can be directly merged only by modifying the variable names to avoid coverage; the attribute analysis module is used for carrying out equivalence conversion on the attribute assertion, converting all time attributes into always, and adding new attribute variables such as array sum, dictionary sum and the like for the contract according to needs.
The symbolic execution subsystem comprises a compiler module, a control flow graph building module, a branch execution module and a constraint solving module. The compiler module is used for compiling the intelligent contract source code into byte codes; the control flow graph building module builds a control flow graph according to the byte codes; the branch execution module is a modified Etherhouse virtual machine EVM and can symbolically run byte codes and record execution information; the constraint solving module solves the path branch constraint condition using a Z3 solver.
The abstract verification subsystem comprises an initial state generation module, an abstract state conversion module and an attribute verification module. The initial state generation module is used for generating an initial abstract state which accords with attribute assertion; the abstract state conversion module is used for calculating an abstract state from the symbolic state or generating a symbolic state set from the abstract state; the attribute verification module is used for verifying whether the abstract state meets the attribute assertion.
The invention has the beneficial effects that:
the invention provides a method and a system for formalized verification of intelligent contract functional attributes based on symbol execution, which convert the certification of self-defined functional attributes into reachability verification through contract attribute analysis, and provide a new way for formalized verification by utilizing symbol execution automation. The invention can automatically carry out formalized verification on the intelligent contract function attribute and output the counterexample of the non-conforming attribute, and can effectively improve the efficiency of symbol execution reachability verification by combining the inductive verification and the iteration fixed point method through the pretreatment of the contract attribute.
Drawings
FIG. 1 is a flow chart of a method for formally verifying a functional attribute of an intelligent contract based on symbolic execution according to the present invention.
Fig. 2 is a block diagram of a system for formally verifying a functional attribute of an intelligent contract based on symbolic execution according to an embodiment of the present invention.
Detailed Description
The invention will be further described by way of examples, without in any way limiting the scope of the invention, with reference to the accompanying drawings.
The invention provides a method and a system for formalized verification of intelligent contract functional attributes based on symbol execution, which convert the certification of self-defined functional attributes into reachability verification through contract attribute analysis, and provide a new way for formalized verification by utilizing symbol execution automation.
Fig. 1 is a flow chart of the verification method of the present invention, and the specific implementation includes four stages:
stage one, preprocessing contracts and attributes;
stage two, trying to perform induction certification on the attributes;
thirdly, executing iteration immobile points by using the symbols to obtain a reachable state set;
and fourthly, performing attribute verification or constructing a counter example according to the reachable state set.
Wherein, the first stage comprises the following steps:
step 1, receiving one or more contracts C1，C2…CmAnd inputting a series of custom attribute assertions phi1，φ2…φnThe attribute assertion is equivalently transformed into □ phi1’，□φ2’…□φnForm of' □ phii' representing attribute assertion phiiThe constant holds true.
The custom attribute assertion takes a syntax form similar to solid, for example, always (sum of values of 10000) indicates that the sum of values of mapping balans in the dog coin contract is always equal to 10000.
Attribute assertions that are not always can be equivalently converted, for example, while mintSwitch is false, sum (cat in. balance. value) that represents the sum of values of mapping balances in cat in. sol contract can be converted into always (mintSwitch | (| | mintSwitch & & sum (cat in. balance. value) |)).
Step 2, merging a series of input contracts into a contract C0In the example of solidity, a plurality of contract files are imported with reference to each other and merged one by one according to import relationships, and in addition, to prevent conflicts, a prefix of a contract file name is added to a variable name.
Step 3, if secondary information of variables is involved in the attribute assertion, such as sum (cam in. balance. value) used for representing sum of values of mapping balances, adding new attribute variables at corresponding positions of the contract according to the attribute assertion for representing the information, inserting monitoring codes, and obtaining instrumented contract CφContaining the function { f }1，f2…fk}。
Step 4, according to the pile inserting contract CφAnd equivalent transformed attribute assertion □ phi1’，□φ2’…□φn' the abstract state required for the resolution, α, contains all the variables involved by the attribute assertion and the new attribute variables inserted according to its secondary information.
The second stage comprises the following steps:
step 5, the contract will run in the following loop form, without regard to invoking other external contracts within the contract:
therefore, firstly, the inductive verification is considered, namely, for an attribute needing to be verified, phi' is asserted, and the initialization abstract state alpha is constructed through init, namely, the construction code of the contractinitChecking at αinitThe following attribute asserts whether φ' holds. If yes, go to step 6, otherwise, the contract C is executedφUnsatisfying an attribute assertion φ', i.e. attesting to an input contract C1，C2…CmNot satisfying the attribute asserts phi.
Step 6, the initialized abstract state alpha is processedinitConversion to an initial set of symbol states S0{s10，s20…sm0}。
Step 7, a control flow graph is constructed according to the contract, each state in the initial symbol state set is taken as an initial state, and the function f is executed in a branch modeiObtaining a symbol state set Si{s1i，s2i…smiAnd is converted to abstract state set ai{α1i，α2i…αmiThis stage is performed the same as the conventional symbol.
Step 8, if the initial symbol state set S generated by phi' is asserted for a certain attribute0Separately execute { f }1，f2…fkThe resulting set of symbol states SiAnd its corresponding abstract state set AiIf both phi ' are still true, then phi ' is the generalizable assertion of the attribute and phi ' is always true, i.e. the input contract C is asserted1，C2…CmThe satisfied attribute asserts phi. If not, go to step 9.
The third stage comprises the following steps:
step 9, according to the initialized abstract state alpha constructed in the step 5initInitializing reachable abstract state set reach (C)φ)0＝{αinit}。
Step 10, executing once while loop in symbol mode, calling fiAnd calculating the exact symbolic state s after the transaction has ended, s being in fact a different path constraint p1 { [ nu ] p2 { [ nu ] … } { [ nu ] p }kAll possibilities of (1), including s1，s2…skThe branch path information is recorded during the branch execution process, and is used for constructing a counter-example when the branch execution process is not established.
Step 11, according to the precise symbol state s1，s2…skCalculating an abstract State α1，α2…αmSince different symbol states may get the same abstract state, k ≧ m.
Step 12, abstract state alpha is converted into abstract state1，α2…αmJoining reachable Abstract State set reach (C)φ)0Get a set of reachable abstract states reach (C)φ)1And repeating the steps 10 and 11. Since the abstract variables contained in the abstract state field are finite, the final reach (C)φ) Must reach a stationary point reach (C)φ)i+1＝reach(Cφ)i。
The fourth stage comprises the following steps:
step 13, according to the reachable abstract state set, the indefinite point reach (C)φ)fixVerifying whether attribute assertion phi' is satisfied, and if so, proving the contract CφSatisfying the attribute assertion φ', equivalently validating the input contract C1，C2…CmThe property is satisfied and if not, step 14 is entered.
Step 14, trying to review the path information of the recorded symbol execution according to the symbol state corresponding to the abstract state, trying to construct a counter-example { (user, func, args)1，(user,func,args)2…(user,func,args)nAnd output, proving the input contract C1，C2…CmNot satisfying the attribute asserts phi.
By using the method for performing formal verification on the intelligent contract functional attribute based on symbol execution, the present invention implements a corresponding apparatus for performing formal verification on the intelligent contract functional attribute based on symbol execution, and fig. 2 is a structural block diagram of the intelligent contract attribute formal verification system provided in this embodiment, and includes the following subsystems:
the subsystem is uniform, and the contract attribute is analyzed;
a second subsystem and a symbol execution subsystem;
and a third subsystem and an abstract verification subsystem.
The subsystem comprises the following modules:
the first module and the contract merging module are used for merging a plurality of contracts into one contract according to import hierarchical relation of import, and in addition, prefixes are added to variable names to avoid naming conflict;
and the second module and the attribute analysis module are used for carrying out equivalence conversion on the attribute assertions, converting time attributes into always, and adding new attribute variables such as array sum, dictionary sum and the like for the contracts according to needs.
The second subsystem comprises the following modules:
the third module is a compiler module which selects a solid official compiler with a corresponding version according to the contract to compile the intelligent contract source code into byte codes and simultaneously reserves the information corresponding to the variables and the codes;
the module IV is a control flow graph construction module which constructs a control flow graph according to byte codes;
a fifth module and a branch execution module which is a modified Ethengfang virtual machine EVM and can symbolize a running byte code and record execution information;
and a sixth module for solving the constraint conditions of the path branches by using a Z3 solver.
The subsystem III comprises the following modules:
a seventh module, an initial state generating module, configured to generate an initial abstract state that meets the attribute assertion, where a concrete constraint needs to be resolved from the attribute assertion first, and an abstract state with the constraint is generated;
the module eight and the abstract state conversion module can realize the mutual conversion of the symbolic state and the abstract state, wherein the symbolic state to the abstract state can be obtained through calculation, and a symbolic state set generated by the abstract state can be obtained through symbolization with constraint;
and the attribute verification module can convert the attribute verification into a joint solution with the abstract state by converting the attribute assertion into the constraint condition, and verify whether the abstract state meets the attribute assertion.
It is noted that the disclosed embodiments are intended to aid in further understanding of the invention, but those skilled in the art will appreciate that: various substitutions and modifications are possible without departing from the spirit and scope of the invention and appended claims. Therefore, the invention should not be limited to the embodiments disclosed, but the scope of the invention is defined by the appended claims.
Claims (6)
1. A method for formalizing and verifying the functional attribute of an intelligent contract based on symbol execution comprises the steps of formalizing a self-defined functional attribute into an attribute assertion, then abstracting the attribute assertion to try generalized verification through symbol execution, and if the attribute assertion has the generalizability, directly proving; if the attribute can be successfully derived, the attribute is proved to be asserted, otherwise, the construction of counter-example output is attempted; the method specifically comprises the following steps:
1) receiving one or more contracts C1，C2…CmAnd inputting a series of custom attribute assertions phi1，φ2…φnThe attribute assertion is equivalently transformed into □ phi1’，□φ2’…□φn' form, wherein □ phii' representing attribute assertion phii' constant, m, n, i represent natural numbers;
2) merging a series of contracts into one contract C0；
3) Adding new attributes at corresponding positions of contracts according to attribute assertionsThe property variable is inserted into the monitoring code to obtain the instrumentation contract CφContaining the function { f }1，f2…fkH, wherein k represents a natural number;
4) according to the stake-inserting contract CφAnd equivalent transformed attribute assertion □ phi1’，□φ2’…□φn' resolving the required abstract state α;
5) for an attribute assertion phi' needing verification, an initialized abstract state alpha is constructed by initinitChecking at αinitIf the lower attribute assertion is established, the method goes to step 6 if the lower attribute assertion is established, and if the lower attribute assertion is not established, the method inserts a contract CφUnsatisfying an attribute assertion φ', i.e. attesting to an input contract C1，C2…CmNot satisfying the attribute assertion φ;
6) abstract state alpha to be initializedinitConversion to an initial set of symbol states S0{s10，s20…sm0}；
7) Taking each state in the initial symbol state set as an initial state, executing the function fiObtaining a symbol state set Si{s1i，s2i…smiAnd converted into an abstract state set Ai{α1i，α2i…αmi}；
8) If the initial symbol state set S generated by phi' is asserted for a property0Respectively execute { f1，f2…fkThe resulting set of symbol states SiAnd its corresponding abstract state set AiIf both phi ' are still true, then phi ' is the generalizable proof attribute assertion and phi ' is always true, i.e. the input contract C is proved1，C2…CmSatisfies attribute assertion phi; if not, entering step 9;
9) according to the initialized abstract state alpha constructed in the step 5)initInitializing reachable abstract state set reach (C)φ)0＝{αinit}；
10) Performing a while loop symbolically, calling fiAnd calculating the exact symbol state s, s after the transaction is over, s being actuallyDifferent path constraints p1 { [ MoH ] } p2 { [ MoH ] } … } { [ MoH ] pkAll possibilities of (1), including s1，s2…sk；
11) According to the precise symbol state s1，s2…skCalculating an abstract State α1，α2…αmSince different symbol states may obtain the same abstract state, k is greater than or equal to m;
12) abstract state alpha1，α2…αmJoining reachable Abstract State set reach (C)φ)0Get a set of reachable abstract states reach (C)φ)1Repeating steps 10) and 11); since the abstract state field is limited, the final reach (C)φ) Must reach a stationary point reach (C)φ)i+1＝reach(Cφ)i；
13) Indefinite Point reach (C) from reachable Abstract State setφ)fixVerifying whether attribute assertion phi' is satisfied, and if so, proving the contract CφSatisfying the attribute assertion φ', equivalently validating the input contract C1，C2…CmIf the attribute is satisfied, the method proceeds to step 14);
14) trying to check back the path information of the recorded symbolic execution according to the symbolic state corresponding to the abstract state, trying to construct a counter-example { (user, func, args)1，(user,func,args)2…(user,func,args)nAnd output, proving the input contract C1，C2…CmNot satisfying the attribute asserts phi.
2. The method as claimed in claim 1, wherein in step 1), the custom property assertion takes a syntax form similar to solid, such as always (sum of values of matching libraries in the contract of matching libraries 10000) indicates that the sum of values of matching libraries in the contract of matching libraries is equal to 10000; attribute assertions that are not always are converted equivalently, such as while mintSwitch is false, sum (cat in. balance. value) that represents the sum of values of mapping balances in cat in. sol contract will be converted to always (mintSwitch & & sum (cat in. balance. value): balance)).
3. A method as claimed in claim 2, wherein in step 2) a plurality of contract files are imported with reference to each other, merged one by one according to import relations of import, and further, to prevent conflicts, a variable name is prefixed with a contract file name.
4. A system for formalized verification of intelligent contract function attribute based on symbol execution comprises a contract attribute analysis subsystem, a symbol execution subsystem and an abstract verification subsystem; wherein:
the contract attribute analysis subsystem comprises a contract merging module and an attribute analysis module, and the contract merging module is used for merging a plurality of contracts into one contract; the attribute analysis module is used for carrying out equivalent transformation on the attribute assertion and adding a new attribute variable for the contract according to the requirement;
the symbolic execution subsystem comprises a compiler module, a control flow graph construction module, a branch execution module and a constraint solving module, wherein the compiler module is used for compiling the intelligent contract source code into byte codes; the control flow graph building module builds a control flow graph according to the byte codes; the branch execution module is a modified Etherhouse virtual machine EVM and can symbolically run byte codes and record execution information; the constraint solving module solves the path branch constraint condition by using a Z3 solver;
the abstract verification subsystem comprises an initial state generation module, an abstract state conversion module and an attribute verification module, wherein the initial state generation module is used for generating an initial abstract state which accords with attribute assertion; the abstract state conversion module is used for calculating an abstract state from the symbolic state or generating a symbolic state set from the abstract state; the attribute verification module is used for verifying whether the abstract state meets attribute assertion.
5. The system of claim 4, wherein the contract merge module directly merges multiple contracts into one contract by modifying only variable names to avoid overrides according to the syntax of solidity.
6. The system of claim 4, wherein the attribute parsing module converts each time attribute to always, the new attribute variables comprising an array sum, a dictionary sum.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210047615.4A CN114510414B (en) | 2022-01-17 | 2022-01-17 | Method and system for formalized verification of intelligent contract function attribute based on symbol execution |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210047615.4A CN114510414B (en) | 2022-01-17 | 2022-01-17 | Method and system for formalized verification of intelligent contract function attribute based on symbol execution |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114510414A true CN114510414A (en) | 2022-05-17 |
| CN114510414B CN114510414B (en) | 2024-05-17 |
Family
ID=81550509
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210047615.4A Active CN114510414B (en) | 2022-01-17 | 2022-01-17 | Method and system for formalized verification of intelligent contract function attribute based on symbol execution |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114510414B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117667676A (en) * | 2023-11-21 | 2024-03-08 | 上海金仕达卫宁软件科技有限公司 | AIGC-based block chain intelligent contract IDE verification test method and system |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040107174A1 (en) * | 2002-12-03 | 2004-06-03 | Jones Robert B. | Parametric representation methods for formal verification on a symbolic lattice domain |
| US20040230407A1 (en) * | 2003-04-15 | 2004-11-18 | Nec Laboratories America, Inc | Iterative abstraction using SAT-based BMC with proof analysis |
| US20150213167A1 (en) * | 2014-01-29 | 2015-07-30 | Synopsys, Inc. | Invariant sharing to speed up formal verification |
| CN108985073A (en) * | 2018-07-18 | 2018-12-11 | 成都链安科技有限公司 | A kind of supermatic intelligent forms of contract chemical examination card system and method |
| CN110515856A (en) * | 2019-09-02 | 2019-11-29 | 华东师范大学 | A kind of Test cases technology system executed based on dynamic symbol |
| CN113672515A (en) * | 2021-08-26 | 2021-11-19 | 北京航空航天大学 | WASM intelligent contract vulnerability detection method based on symbolic execution |
| CN113688403A (en) * | 2021-10-26 | 2021-11-23 | 江苏通付盾科技有限公司 | Intelligent contract vulnerability detection method and device based on symbolic execution verification |
-
2022
- 2022-01-17 CN CN202210047615.4A patent/CN114510414B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040107174A1 (en) * | 2002-12-03 | 2004-06-03 | Jones Robert B. | Parametric representation methods for formal verification on a symbolic lattice domain |
| US20040230407A1 (en) * | 2003-04-15 | 2004-11-18 | Nec Laboratories America, Inc | Iterative abstraction using SAT-based BMC with proof analysis |
| US20150213167A1 (en) * | 2014-01-29 | 2015-07-30 | Synopsys, Inc. | Invariant sharing to speed up formal verification |
| CN108985073A (en) * | 2018-07-18 | 2018-12-11 | 成都链安科技有限公司 | A kind of supermatic intelligent forms of contract chemical examination card system and method |
| CN110515856A (en) * | 2019-09-02 | 2019-11-29 | 华东师范大学 | A kind of Test cases technology system executed based on dynamic symbol |
| CN113672515A (en) * | 2021-08-26 | 2021-11-19 | 北京航空航天大学 | WASM intelligent contract vulnerability detection method based on symbolic execution |
| CN113688403A (en) * | 2021-10-26 | 2021-11-23 | 江苏通付盾科技有限公司 | Intelligent contract vulnerability detection method and device based on symbolic execution verification |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117667676A (en) * | 2023-11-21 | 2024-03-08 | 上海金仕达卫宁软件科技有限公司 | AIGC-based block chain intelligent contract IDE verification test method and system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114510414B (en) | 2024-05-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11416226B2 (en) | System and method for compiling high-level language code into a script executable on a blockchain platform | |
| Cruz-Filipe et al. | Efficient certified resolution proof checking | |
| López et al. | Protocol-based verification of message-passing parallel programs | |
| Graillat et al. | Auto-tuning for floating-point precision with Discrete Stochastic Arithmetic | |
| Hooimeijer et al. | StrSolve: solving string constraints lazily | |
| Shankar et al. | The mechanical verification of a DPLL-based satisfiability solver | |
| Yang et al. | Formal process virtual machine for smart contracts verification | |
| Leinenbach et al. | Pervasive compiler verification–from verified programs to verified systems | |
| Shishkin | Debugging smart contract’s business logic using symbolic model checking | |
| CN116341428B (en) | Method for constructing reference model, chip verification method and system | |
| Roy et al. | SimCheck: An expressive type system for Simulink | |
| CN113504900A (en) | Programming language conversion method and device | |
| Wesley et al. | Verifying Solidity smart contracts via communication abstraction in SmartACE | |
| CN110196720A (en) | A kind of Simulink generates the optimization method of dynamic link library | |
| CN106648813B (en) | Formalized compiling method for synchronous data stream program | |
| CN114510414B (en) | Method and system for formalized verification of intelligent contract function attribute based on symbol execution | |
| US7500220B1 (en) | Shared code management | |
| Cristiá et al. | A language for test case refinement in the Test Template Framework | |
| Marmsoler et al. | Conformance testing of formal semantics using grammar-based fuzzing | |
| KR20090041996A (en) | A system and method estimating automatically the worst-case execution time of realtime systems by using implicit path enumeration technique | |
| Zhang | An Approach for Extracting UML Diagram from Object-Oriented Program Based on J2X | |
| Narodytska et al. | Analysis of core-guided MaxSat using cores and correction sets | |
| Meng et al. | Towards Developing Trusted Smart Contracts in Simulink. | |
| Joshi et al. | Automatic generation of fault trees from AADL models | |
| Tinnerholm | An LLVM backend for the Open Modelica Compiler |
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 |