A smart contract write-after-read risk detection method and electronic device
By analyzing the source code of the smart contract, generating a method call chain, and detecting the read-after-write risk of the smart contract, the problem of low detection accuracy and efficiency in the existing technology is solved, and effective risk detection of read and write operations in multiple functions is achieved. .
Patent Information
- Application Number
- CN202211371912.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2022-11-03
- Publication Date
- 2024-12-03
- Estimated Expiration
- 2042-11-03
AI Technical Summary
The existing smart contract read-after-write risk detection method only supports detection within a single function, and cannot detect risks caused by the combination of read and write operations in multiple functions. In addition, the detection method based on text location has false positives and missed reports, resulting in detection accuracy. and inefficient.
By obtaining the source code of the smart contract, performing lexical analysis and grammatical analysis, building an abstract syntax tree, identifying and extracting key methods, generating method call chains, detecting the risk of reading after writing, and considering special statements that affect the execution order.
It improves the accuracy and efficiency of smart contract post-write read risk detection, can detect risks caused by combinations of read and write operations in multiple functions, and reduces false positives and missed reports.
Smart Images

Figure CN115879945B_ABST
Abstract
Description
Technical Field
[0001] The present application relates to the field of information security technology, and in particular to a smart contract read-after-write risk detection method and electronic device. Background Art
[0002] With the development of blockchain technology and the requirements of institutions or organizations such as banks, insurance, and securities for privacy protection and processing performance in blockchain technology, alliance chain technology was born. Alliance chain is a cluster composed of multiple private chains, a blockchain jointly managed by multiple institutions. Each organization or institution manages one or more nodes, and its data is only allowed to be read, written or sent by different institutions in the system. The main alliance chain platforms include Hyperledger, etc. Among them, Hyperledger includes technologies such as Hyper ledger Fabric.
[0003] Hyper ledger Fabric is an open source project initiated by the Linux Foundation in 2015 to promote blockchain digital technology and transaction verification. Due to its modular design and support for implementing different components in a pluggable manner, it has become the most popular alliance chain platform for enterprise-level applications. In Hyper ledger Fabric, smart contracts are the medium for applications to interact with the underlying layer. By calling smart contracts, transactions are automatically executed and ledger data is operated. The above smart contracts are written using general programming languages (mainly Golang). This can reduce the learning cost of developers and enrich the scenarios that smart contracts can express by using the extensibility of general programming languages. However, due to the developer's understanding of the difference between ordinary programs and smart contracts, and the unfamiliarity with the underlying operating logic of the platform, there are potential risks in smart contracts. The most typical one is the write-after-read risk in smart contracts, that is, the developer does not accurately understand the semantics of the read-write method, or does not consider the three-stage execution framework of the smart contract "execution-sorting-verification", resulting in the reading of data that has just been written into the ledger database during the writing of the smart contract, which ultimately leads to data inconsistency.
[0004] The detection of write-after-read risks of smart contracts in the related technologies still has the following shortcomings: it only supports the detection of write-after-read risks within a single function, and the write-after-read risks caused by the combination of read and write operations in multiple functions cannot be detected; it only supports the detection of write-after-read risks based on text positions, and simply takes the code position of the read and write methods as the only indicator for detection, without considering the special statements that can really affect the execution order, resulting in a large number of false positives and missed negatives. The above shortcomings of the related technologies lead to the high accuracy and efficiency of the read-after-write risk detection of smart contracts. Summary of the invention
[0005] In view of this, the purpose of this application is to propose a smart contract write-after-read risk detection method and electronic device.
[0006] Based on the above purpose, this application provides a smart contract write-after-read risk detection method, including:
[0007] Obtain the source code of the smart contract;
[0008] Performing lexical analysis and grammatical analysis on the source code to obtain an abstract syntax tree;
[0009] Identify and extract the abstract syntax tree to obtain a key method of the abstract syntax tree;
[0010] Sorting the key methods to obtain a method call chain;
[0011] According to the method call chain, the write-after-read risk of the smart contract is detected.
[0012] Optionally, the key method of obtaining the abstract syntax tree by identifying and extracting the abstract syntax tree includes:
[0013] Traversing all declaration nodes of the abstract syntax tree, extracting all corresponding function names, and obtaining a global function name list;
[0014] Traversing the subtrees of all declaration nodes of the abstract syntax tree to determine the types of nodes in the subtrees of the declaration nodes;
[0015] In response to determining that the type of a node in the subtree of any of the declaration nodes belongs to a predetermined call expression, extracting an identification of the node;
[0016] In response to determining that the identifier of the node belongs to the global list of function names, saving the node in a key method structure;
[0017] Add the key method to the first key method set.
[0018] Optionally, the key method of obtaining the abstract syntax tree by identifying and extracting the abstract syntax tree further includes:
[0019] Traversing all subtrees in the abstract syntax tree with the declaration node as the root node, and determining all subtrees that satisfy a predetermined structure;
[0020] In response to determining that a root node in any of the subtrees satisfies a predetermined condition, storing the root node in a structure of a key method;
[0021] Add the key method to the second key method set.
[0022] Optionally, the predetermined structure includes:
[0023] The root node belongs to the predetermined call expression;
[0024] The successor node of the root node is a predetermined selector node;
[0025] The successor nodes of the predetermined selector node are the first identification node and the second identification node;
[0026] The first identification node is a stub code;
[0027] The second identification node is a code for storing data or a code for obtaining data.
[0028] Optionally, in response to determining that a root node in any of the subtrees satisfies a predetermined condition, storing the root node in a key method structure includes:
[0029] In response to determining that the parent node of the root node of the subtree is a delay statement node, the root node is saved in a key method structure, and the key method is added to a second key method set.
[0030] Optionally, in response to determining that a root node in any of the subtrees satisfies a predetermined condition, storing the root node in a key method structure further includes:
[0031] In response to determining that the parent node of the root node of the subtree is not a delay statement node, the root node is saved in a key method structure, and the key method is added to a third key method set.
[0032] Optionally, the key methods are sorted to obtain a method call chain, including:
[0033] In response to determining that the key method belongs to the first key method set or the third key method set, sorting the key methods from small to large according to the position attribute to obtain a first subchain;
[0034] In response to determining that the key method belongs to the second key method set, sorting from largest to smallest according to the position attribute to obtain a second subchain;
[0035] The first subchain is connected to the second subchain to obtain the method call chain.
[0036] Optionally, detecting the read-after-write risk of the smart contract according to the method call chain includes:
[0037] In response to determining that a key method pair in the method call chain satisfies a preset condition, comparing parameters of the key method pair;
[0038] In response to determining that the parameters of the key method pair are the same, it is determined that the smart contract has a read-after-write risk.
[0039] Optionally, in response to determining that the key method pair in the method call chain satisfies a preset condition, comparing parameters of the key method pair includes:
[0040] Determine at least one key method pair according to the method call chain;
[0041] Determining the symbolic names of the preceding key method and the succeeding key method in the key method pair;
[0042] In response to determining that the symbolic name of the preceding key method pair is deposit data and the symbolic name of the succeeding key method pair is get data, parameters of the key method pairs are compared.
[0043] Based on the same inventive concept, the present application also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, the smart contract write-after-read risk detection method as described in any one of the above items is implemented.
[0044] From the above, it can be seen that the smart contract write-after-read risk detection method provided by this application converts the analysis of smart contracts into analysis of key methods by identifying and extracting key methods of the method call chain obtained according to the smart contract source code. Constructing the method call chain through key methods can reflect the actual execution order of key methods related to the write-after-read risk, covering a variety of detection scenarios. Not only can the write-after-read risk within a single function be detected, but also the write-after-read risk caused by the combination of read and write operations in multiple functions can be detected. At the same time, the method provided by this application can take into account special statements that affect the execution order.
[0045] Therefore, the method provided in this application can effectively improve the detection accuracy and efficiency of write-after-read risks of smart contracts. BRIEF DESCRIPTION OF THE DRAWINGS
[0046] In order to more clearly illustrate the technical solutions in the present application or related technologies, the drawings required for use in the embodiments or related technical descriptions are briefly introduced below. Obviously, the drawings described below are only embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.
[0047] Figure 1 A schematic diagram of a method flow of one or more embodiments of the present application;
[0048] Figure 2 A schematic diagram of a subtree structure of one or more embodiments of the present application;
[0049] Figure 3 A schematic diagram of the hardware structure of an electronic device according to one or more embodiments of the present application. DETAILED DESCRIPTION
[0050] In order to make the objectives, technical solutions and advantages of the present application more clearly understood, the present application is further described in detail below in combination with specific embodiments and with reference to the accompanying drawings.
[0051] It should be noted that, unless otherwise defined, the technical terms or scientific terms used in the embodiments of the present application should be the usual meanings understood by people with ordinary skills in the field to which the present application belongs. The "first", "second" and similar words used in the embodiments of the present application do not represent any order, quantity or importance, but are only used to distinguish different components. "Including" or "comprising" and similar words mean that the elements or objects appearing in front of the word cover the elements or objects listed after the word and their equivalents, without excluding other elements or objects. "Connect" or "connected" and similar words are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. "Up", "down", "left", "right" and the like are only used to indicate relative positional relationships. When the absolute position of the described object changes, the relative positional relationship may also change accordingly.
[0052] As described in the background technology, the alliance chain is based on blockchain technology and proposes a more powerful solution in terms of privacy protection and processing performance. The alliance chain platform mainly includes Hyperledger and the like. Among them, Hyperledger includes technologies such as Hyper ledger Fabric. Smart contract is a computer protocol designed to spread, verify or execute contracts in an information-based manner. It is a medium for platform applications to interact with the underlying layer. By calling smart contracts, the automatic execution of transactions and the operation of ledger data can be realized. Smart contracts in Hyper ledger Fabric ledgers are usually portable using general programming languages such as Golang. However, risks such as write-after-read are prone to occur during its writing process. The related technology still has the following shortcomings in the detection of write-after-read risks of smart contracts: it only supports write-after-read risk detection within a single function, and the write-after-read risks caused by the combination of read and write operations in multiple functions cannot be detected; it only supports write-after-read risk detection based on text position, and simply takes the code position of the read-write method as the only indicator for detection, without considering special statements that can really affect the execution order, resulting in a large number of false positives and missed reports. The above shortcomings of the related technology lead to the accuracy and efficiency of read-after-write risk detection of smart contracts.
[0053] Therefore, this application proposes a method for detecting the risk of read-after-write of smart contracts. The above method identifies and extracts the abstract syntax tree obtained from the source code of the smart contract to obtain the corresponding key method. Then, the execution order and function of the method call chain generated by the key method are detected to improve the detection accuracy and efficiency of the risk of read-after-write.
[0054] The technical solutions of one or more embodiments of the present application are described in detail below through specific examples.
[0055] refer to Figure 1 The smart contract write-after-read risk detection method of one or more embodiments of the present application includes the following steps:
[0056] Step S101: Obtain the source code of the smart contract.
[0057] Step S102: performing lexical analysis and grammatical analysis on the source code to obtain an abstract syntax tree.
[0058] An abstract syntax tree is a tree representation of the abstract syntax structure of source code written in a programming language, with each node representing a construct that occurs in the source code.
[0059] In this step, the source code obtained in step S101 is subjected to lexical analysis and grammatical analysis to obtain an abstract syntax tree. In some embodiments, the smart contract can be subjected to lexical analysis by a lexical analyzer, and the source code can be divided into at least one token. Then the token stream is read by a grammatical analyzer to generate an abstract syntax tree. In some embodiments, the lexical analyzer can select a scanner tool. In some embodiments, the grammatical analyzer can select a parser tool. In this process, the character sequence is first converted into a token through lexical analysis. That is, the code is first scanned line by line, each word is identified, and the type of each word is determined. Then the identified words are converted into a unified token form. The above token is composed of <category code, attribute value>, and the category code is the type of token. Then, the obtained token is subjected to a grammatical analyzer to construct a data structure to obtain an abstract syntax tree. In some embodiments, an abstract syntax tree can be obtained by top-down analysis or bottom-up analysis.
[0060] In some embodiments, the above-mentioned abstract syntax tree can also be pruned. The purpose is to remove the subtree with GenDecl as the root node that is not related to the write-after-read risk detection. In some embodiments, the pruning operation includes the following steps: starting from the root node of the abstract syntax tree, traversing the abstract syntax tree; pruning the subtree with GenDecl as the root node. GenDecl, as an import declaration node, mainly includes external packages introduced in the smart contract, which is not related to the detection of write-after-read risks. After the abstract syntax tree is pruned, only the subtree with FuncDecl as the root node is retained, and each subtree represents the function body defined with the func keyword in the smart contract.
[0061] Step S103: performing identification and extraction according to the abstract syntax tree to obtain key methods of the abstract syntax tree.
[0062] Key methods refer to the method call information related to the write-after-read risk on the above-mentioned smart contract. In some embodiments, the key methods can be defined to include the following attributes: key method name (Name), key method type (Type), key method position in the code (Pos), and key method call parameters (Param). Among them, Name mainly includes "PutState", "GetState" or function name; Type mainly has three types, 0 represents ordinary method, 1 represents special statement method, and 2 represents function method.
[0063] In some embodiments, the key methods are of two types: indirect call and direct call. In some embodiments, for the indirect call class, the key method set can be obtained by the following steps: first, starting from the root node of the above abstract syntax tree, all FuncDecl function declaration child nodes are traversed. The function name is extracted from the above at least one FuncDecl function declaration child node structure to obtain a global function name list. Then, starting with the above FuncDecl function declaration child node, the subtree with the child node as the root node is traversed. During the traversal process, if the node type meets the predetermined CallExpr call expression, the Ident identifier in the CallExpr node in the subtree is extracted. If the Ident identifier exists in the global function name list, it means that there is a call relationship between functions. For example, during the traversal process of the abstract syntax subtree of function A, there is a CallExpr node with an Ident of B and B belongs to the global function name list, then it is considered that function A calls function B. In some embodiments, the above-mentioned CallExpr node found is saved in the key method structure, the Name of the key method is the function name, the Type can be set to 2, and the Pos can be obtained through the Pos() method of the node. Finally, add the key method to the key method collection.
[0064] In some embodiments, for a direct call class, the key method set can be obtained by the following steps: first, starting from the root node of the above abstract syntax tree, all FuncDecl function declaration child nodes are traversed to determine a subtree that meets a predetermined structure. In some embodiments, this predetermined structure can be as follows: Figure 2 The three-layer subtree structure shown. Among them, the root node of the subtree structure is the CallExpr call expression node, and its successor node is the SelectorExpr selector node. The successor nodes of the SelectorExpr node are two Ident identification nodes, and the specific contents are stub and PutState or GetState, indicating the two read and write methods of PutState and GetState. When it is determined that the subtree meets the above predetermined structure, determine whether the parent node of the CallExpr node is a DeferStmt delay statement node. If so, it means that the key method exists in a special statement. Finally, the above CallExpr node is saved in the key method structure, where Name is the function name, Pos can be obtained through the Pos() method of the node, and Param can be obtained through the Ident of the CallExpr node. The Type in the structure of the key method is set to 1 or 0 according to whether the key method exists in a special statement. Finally, the above key method is added to different key method sets according to its Type.
[0065] Step S104: sort the key methods to obtain a method call chain.
[0066] After at least one key method is obtained through step S103, all key methods are sorted using the method call chain. In some embodiments, the principle of sorting is carried out according to the calling order of the key methods. In some embodiments, the specific method of obtaining the method call chain may include: according to the type of the key method, all the above key methods are divided into two subsets. The first subset includes key methods of Type 0 or 2, and the second subset includes key methods of Type 1. Since the calling order of the key methods of the first subset corresponds to their positions in the code, in some embodiments, the key methods in the subset can be formed into a first subchain in the order of position attributes from small to large. Since the key methods of the second subset exist in the defer statement, according to the first-in-last-out execution characteristics of the defer statement, in some embodiments, the key methods in the subset can be formed into a second subchain in the order of position attributes from large to small. After that, the second subchain is connected to the first subchain to form a method call chain.
[0067] In some embodiments, after the method call chain is obtained by the above method, there are still key methods of indirect call type. In some embodiments, the influence of indirect call can be eliminated by expanding the key methods of Type 2 in the method call chain into the corresponding method call chain.
[0068] Step S105: Detect the read-after-write risk of the smart contract according to the method call chain.
[0069] The method call chain obtained in step S104 is scanned, and if there is a key method pair that meets the preset conditions, the parameter attributes of the key method pair are compared. If the above parameters are the same, it is considered that a write-after-read risk may be caused. In some embodiments, the above preset condition is that the name of the previous key method of the key method pair is PutState, and the name of the subsequent key method is GetState.
[0070] In some embodiments, a risk detection report is issued based on the read-after-write risk detection result obtained by the above method, and the detection time and the code location where the read-after-write risk exists are output.
[0071] It should be noted that the method of the embodiment of the present application can be performed by a single device, such as a computer or server. The method of this embodiment can also be applied to a distributed scenario and completed by multiple devices cooperating with each other. In the case of such a distributed scenario, one of the multiple devices can only perform one or more steps in the method of the embodiment of the present application, and the multiple devices will interact with each other to complete the described method.
[0072] It should be noted that the above describes some embodiments of the present application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the above embodiments and still achieve the desired results. In addition, the processes depicted in the accompanying drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
[0073] Based on the same inventive concept, corresponding to any of the above-mentioned embodiments and methods, the present application also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, the smart contract write-after-read risk detection method described in any of the above embodiments is implemented.
[0074] Figure 3A more specific schematic diagram of the hardware structure of an electronic device provided in this embodiment is shown, and the device may include: a processor 1010, a memory 1020, an input / output interface 1030, a communication interface 1040, and a bus 1050. The processor 1010, the memory 1020, the input / output interface 1030, and the communication interface 1040 are connected to each other through the bus 1050 in the device.
[0075] The processor 1010 can be implemented by a general-purpose CPU (Central Processing Unit), a microprocessor, an application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this specification.
[0076] The memory 1020 may be implemented in the form of ROM (Read Only Memory), RAM (Random Access Memory), static storage device, dynamic storage device, etc. The memory 1020 may store an operating system and other application programs. When the technical solutions provided in the embodiments of this specification are implemented by software or firmware, the relevant program codes are stored in the memory 1020 and are called and executed by the processor 1010.
[0077] The input / output interface 1030 is used to connect the input / output module to realize information input and output. The input / output module can be configured in the device as a component (not shown in the figure), or it can be externally connected to the device to provide corresponding functions. The input device may include a keyboard, a mouse, a touch screen, a microphone, various sensors, etc., and the output device may include a display, a speaker, a vibrator, an indicator light, etc.
[0078] The communication interface 1040 is used to connect a communication module (not shown) to realize communication interaction between the device and other devices. The communication module can realize communication through a wired mode (such as USB, network cable, etc.) or a wireless mode (such as mobile network, WIFI, Bluetooth, etc.).
[0079] The bus 1050 includes a path that transmits information between the various components of the device (eg, the processor 1010, the memory 1020, the input / output interface 1030, and the communication interface 1040).
[0080] It should be noted that, although the above device only shows the processor 1010, the memory 1020, the input / output interface 1030, the communication interface 1040 and the bus 1050, in the specific implementation process, the device may also include other components necessary for normal operation. In addition, it can be understood by those skilled in the art that the above device may also only include the components necessary for implementing the embodiments of the present specification, and does not necessarily include all the components shown in the figure.
[0081] The electronic device of the above-mentioned embodiment is used to implement the corresponding smart contract write-after-read risk detection method in any of the above-mentioned embodiments, and has the beneficial effects of the corresponding method embodiment, which will not be repeated here.
[0082] Those skilled in the art should understand that the discussion of any of the above embodiments is merely illustrative and is not intended to imply that the scope of the present application (including the claims) is limited to these examples. In line with the concept of the present application, the technical features in the above embodiments or different embodiments may be combined, the steps may be implemented in any order, and there are many other variations of the different aspects of the embodiments of the present application as described above, which are not provided in detail for the sake of simplicity.
[0083] In addition, to simplify the description and discussion, and in order not to make the embodiments of the present application difficult to understand, the known power supply / ground connection with the integrated circuit (IC) chip and other components may or may not be shown in the provided drawings. In addition, the device can be shown in the form of a block diagram to avoid making the embodiments of the present application difficult to understand, and this also takes into account the fact that the details of the implementation of these block diagram devices are highly dependent on the platform to be implemented in the embodiments of the present application (that is, these details should be fully within the scope of understanding of those skilled in the art). In the case of elaborating specific details (e.g., circuits) to describe exemplary embodiments of the present application, it is obvious to those skilled in the art that the embodiments of the present application can be implemented without these specific details or when these specific details are changed. Therefore, these descriptions should be considered to be illustrative rather than restrictive.
[0084] Although the present application has been described in conjunction with specific embodiments of the present application, many replacements, modifications and variations of these embodiments will be apparent to those skilled in the art from the foregoing description. For example, other memory architectures (e.g., dynamic RAM (DRAM)) may use the embodiments discussed.
[0085] The embodiments of the present application are intended to cover all such substitutions, modifications and variations that fall within the broad scope of the appended claims. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the embodiments of the present application should be included in the scope of protection of the present application.
Claims
1. A smart contract read-after-write risk detection method, characterized in that: include: Obtain the source code of the smart contract; Performing lexical analysis and grammatical analysis on the source code to obtain an abstract syntax tree; Identify and extract the abstract syntax tree to obtain a key method of the abstract syntax tree; Sorting the key methods to obtain a method call chain; In response to determining that a key method pair in the method call chain satisfies a preset condition, comparing parameters of the key method pair; In response to determining that the parameters of the key method pair are the same, determining that the smart contract has a read-after-write risk; The key method of obtaining the abstract syntax tree by identifying and extracting the abstract syntax tree includes: Traversing all declaration nodes of the abstract syntax tree, extracting all corresponding function names, and obtaining a global function name list; Traversing the subtrees of all declaration nodes of the abstract syntax tree to determine the types of nodes in the subtrees of the declaration nodes; In response to determining that the type of a node in the subtree of any of the declaration nodes belongs to a predetermined call expression, extracting an identification of the node; In response to determining that the identifier of the node belongs to the global list of function names, saving the node in a key method structure; Adding the key method to a first key method set; Traversing all subtrees with the declaration node as the root node in the abstract syntax tree, and determining all subtrees satisfying a predetermined structure; the predetermined structure indicates that the root node belongs to a predetermined call expression, the successor node of the root node is a predetermined selector node, the successor nodes of the predetermined selector node are a first identification node and a second identification node, the first identification node is a stub code, and the second identification node is a code for storing data or a code for obtaining data; In response to determining that the parent node of the root node of the subtree is a delay statement node, storing the root node in a key method structure and adding the key method to a second key method set; In response to determining that the parent node of the root node of the subtree is not a delay statement node, storing the root node in a key method structure and adding the key method to a third key method set; The key methods are sorted to obtain a method call chain, including: In response to determining that the key method belongs to the first key method set or the third key method set, sorting the key methods from small to large according to the position attribute to obtain a first subchain; In response to determining that the key method belongs to the second key method set, sorting from largest to smallest according to the position attribute to obtain a second subchain; The first subchain is connected to the second subchain to obtain the method call chain.
2. According to the smart contract write-after-read risk detection method described in claim 1, it is characterized in that: In response to determining that the key method pair in the method call chain satisfies a preset condition, comparing parameters of the key method pair includes: Determine at least one key method pair according to the method call chain; Determining the symbolic names of the preceding key method and the succeeding key method in the key method pair; In response to determining that the symbolic name of the preceding key method pair is deposit data and the symbolic name of the succeeding key method pair is get data, parameters of the key method pairs are compared.
3. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the program, the method according to any one of claims 1 to 2 is implemented.
Citation Information
Patent Citations
Intelligent contract reentry vulnerability detection method based on abstract syntax tree
CN110162474A
Extensible intelligent contract vulnerability detection method
CN110659494A
Uncertain factor detection device and method for smart contract, and medium
CN110889574A
Smart contract data extraction and synchronization method, system and platform
CN111400303A
Smart contract processing method and device, medium and electronic equipment
CN112104709A
