Syntax information extraction method, device and storage medium based on Solidity smart contract

Abstract

The present invention provides a method, device and storage medium for extracting grammatical information based on Solidity smart contracts, including: calling a first indexing algorithm to construct a first business class corresponding to a current grammatical node and saving the index relationship of the grammatical information of the current grammatical node at the same time; calling a grammatical filling algorithm to fill the grammatical information of the current first business class; calling the next-layer grammatical node business class to fill the grammatical information corresponding to the next-layer business class until all business classes are filled; sorting the inheritance order of the contract to obtain the inheritance line information of each contract so as to accurately realize the tracing of each expression type in the contract. The present invention recursively establishes a tree data structure composed of each grammatical node business class, so that each grammatical node can fully obtain the grammatical information of the grammatical node, thereby solving the problem of incomplete and inaccurate grammatical information extraction in the grammatical information extraction method based on grammatical tree traversal.

Description

Technical Field

[0001] The present application relates to the field of blockchain technology, and specifically to a grammatical information extraction method, device and storage medium based on Solidity smart contract. Background Art

[0002] Smart contracts are a set of commitments defined in digital form. They control digital assets and include the rights and obligations agreed upon by the contract participants, which are automatically executed by computer systems. The combination of smart contracts and blockchain technology is an emerging product and is very immature in technology. There are various business process or technical loopholes from application business to compiler to virtual machine to the underlying blockchain. Many online smart contract projects frequently disclose security issues. Because smart contracts are difficult to tamper with once deployed to the blockchain, how to fully ensure the security of smart contracts before deployment becomes a key step. Most security solutions for verifying smart contracts require syntax-level analysis and auditing of contract code, but often the completeness, accuracy and timeliness of syntax information acquisition cannot be guaranteed. Existing solutions based on syntax analysis can only determine whether risky syntax elements appear in the system from the code level. Such methods cannot judge the actual execution logic of the code and the resulting action results, and have the following problems: 1. Developers need to judge whether a certain section of code has risks based on actual experience and problems that have occurred during program operation. According to established rules, they only traverse the problematic part of the syntax tree, without fully applying the syntax information in the code; 2. Static verification only matches and checks the code grammatically, and cannot accurately perceive the context information in the program. The obtained syntax information is inaccurate and prone to false positives; for example, an int variable age is used to represent the user's age. After one year, the user's age is +1. Static verification will only detect that the addition operation has an overflow risk, but in fact the user's age will not exceed 1000 years old at most. The method of traversing the syntax tree can only find that addition is used here, but cannot find that the operand of the addition is of int type; 3. There is no correlation between the information of each syntax node, and the dynamic operation of the program is not taken into account. When traversing a syntax node, the syntax information declared by other syntax nodes cannot be considered. Summary of the invention

[0003] In view of the above-mentioned defects or deficiencies in the prior art, it is desired to provide a grammatical information extraction method, device and storage medium based on Solidity smart contracts that can accurately and completely extract the latest grammatical information.

[0004] In a first aspect, the present invention provides a method for extracting grammatical information based on a Solidity smart contract, comprising:

[0005] Calling the first indexing algorithm to construct the first business class corresponding to the current grammar node and saving the index relationship of the grammatical information of the current grammar node in the second business class of the parent node of the current node; repeating the above calling steps to establish the corresponding grammatical business class for the child node until a leaf grammar node appears, wherein the construction parameters of the first business class include the grammatical information of the current grammar node and the second grammar business class;

[0006] Call the syntax filling algorithm to fill the syntax information of the current first business class, and complete the type tracing of the variable and determine the scope of the variable; call the next layer of syntax node business class to fill the syntax information corresponding to the next layer of business class until all business classes are filled;

[0007] Sort the inheritance order of the contracts to obtain the inheritance line information of each contract so as to accurately trace the expression types in the contract.

[0008] Further, calling the first indexing algorithm to construct the first service class corresponding to the current syntax node includes:

[0009] Determine whether the current syntax node has a child syntax node:

[0010] If yes, the first service class is constructed according to the current syntax node information and the second language service class.

[0011] Furthermore, the corresponding operations of calling the first indexing algorithm and calling the grammar filling algorithm are both executed recursively from the root node of the grammar tree.

[0012] Furthermore, the step of simultaneously completing the type tracing of the variable and determining the scope of the variable includes:

[0013] Determine whether the current syntax node contains a syntax node for variable definition: if yes, traverse upward from the current syntax node to obtain the type information of the variable;

[0014] The first variable type table of the parent syntax node service class of the current syntax node service class is copied and stored as the second variable type table of the current syntax node, and the variable definition types contained in the current syntax node are updated according to the second variable type table.

[0015] Further, the calling syntax filling algorithm fills the syntax information of the current first business class including at least one of the following: such as compiled version, contract import, contract definition, enumeration definition, structure definition, function definition, library definition, modifier definition, variable name, variable visibility, statement block, code statement, expression.

[0016] Further, the ordering of the inheritance sequence of the contracts to obtain the inheritance line information of each contract so as to accurately trace back each expression type in the contract includes:

[0017] Obtain the direct inheritance information of each contract based on the contract definition information filled in by the calling syntax filling algorithm, that is, which contracts the current contract directly inherits, specified in the inheritanceSpecifier of the contract, and analyze the inheritance relationship between different contracts in the contract file according to the C3 inheritance law followed by the Solidity multi-inheritance mechanism, and finally obtain all the contract information inherited by each contract;

[0018] When performing expression tracing, if the current expression node contains the next-level syntax node, its child expression node information must be determined, and the type information of the current expression must be determined based on the result of the operation;

[0019] The expression type tracing method of the newly created sub-grammar node is called according to the index relationship, so that the current expression business class recursively fills the next layer of expression type information until all expressions in the contract are determined to have specific types.

[0020] In a second aspect, the present invention also provides a device comprising one or more processors and a memory, wherein the memory contains instructions executable by the one or more processors so that the one or more processors execute the grammatical information extraction method based on the Solidity smart contract provided according to various embodiments of the present invention.

[0021] In a third aspect, the present invention also provides a storage medium storing a computer program, which enables a computer to execute the grammatical information extraction method based on the Solidity smart contract provided according to various embodiments of the present invention.

[0022] The grammatical information extraction method, device and storage medium based on Solidity smart contract provided by many embodiments of the present invention recursively establish a tree data structure composed of various grammatical node business classes, so that each grammatical node can fully obtain the grammatical information of the grammatical node, and can also access the grammatical information of the child grammar node or the parent grammar node through the index between the grammar nodes, and can obtain the type information and expression information in the code, which solves the problem of incomplete and inaccurate grammatical information extraction of the grammatical information extraction method based on grammar tree traversal, and achieves the technical effect of being able to fully obtain the contract grammatical information through the tree data structure composed of grammar node business classes. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] Other features, objects and advantages of the present application will become more apparent by reading the detailed description of non-limiting embodiments made with reference to the following drawings:

[0024] Figure 1A flowchart of a method for extracting grammatical information based on a Solidity smart contract is provided in accordance with an embodiment of the present invention.

[0025] Figure 2 for Figure 1 A flow chart of a preferred embodiment of the method is shown.

[0026] Figure 3 for Figure 2 A schematic diagram of a scenario of a preferred implementation of the method shown.

[0027] Figure 4 for Figure 1 A flow chart of a preferred embodiment of the method is shown.

[0028] Figure 5 for Figure 1 A flowchart of a preferred implementation of step S13 in the method is shown.

[0029] Figure 6 for Figure 1 A schematic diagram of a backtracking process scenario of a preferred implementation of the method shown.

[0030] Figure 7 A schematic diagram of the structure of a device provided in one embodiment of the present invention. DETAILED DESCRIPTION

[0031] The present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It is to be understood that the specific embodiments described herein are only used to explain the relevant invention, rather than to limit the invention. It is also necessary to explain that, for ease of description, only the parts related to the invention are shown in the accompanying drawings.

[0032] It should be noted that, in the absence of conflict, the embodiments and features in the embodiments of the present application can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0033] Figure 1 A flowchart of a method for extracting grammatical information based on a Solidity smart contract is provided in accordance with an embodiment of the present invention.

[0034] like Figure 1 As shown, in this embodiment, the present invention provides a grammatical information extraction method based on Solidity smart contract, including:

[0035] S11, calling the first indexing algorithm to construct the first service class corresponding to the current grammar node and saving the index relationship of the grammar information of the current grammar node in the second service class of the parent node of the current node; repeating the above calling steps to establish the corresponding grammar service class for the child node until a leaf grammar node appears, wherein the construction parameters of the first service class include the grammar information of the current grammar node and the second grammar service class;

[0036] S12, calling the syntax filling algorithm to fill the syntax information of the current first business class, and completing the type tracing of the variable and determining the scope of the variable; calling the next layer of syntax node business class to fill the syntax information corresponding to the next layer of business class, until all business classes are filled;

[0037] S13. Sort the inheritance order of the contracts to obtain the inheritance line information of each contract so as to accurately trace each expression type in the contract.

[0038] Specifically, ANTLR syntax parsing can be used before applying this method. Developers use ANTLR to parse the syntax according to the Solidity syntax rules to obtain the information of the syntax parsing tree corresponding to the current contract;

[0039] In step S11, the syntax nodes are traversed and the index of the business class corresponding to the syntax node is newly created. Starting from the root syntax node SourceUnit, each syntax node is traversed according to the relationship of the parse tree, and the first indexing algorithm is called to create the business class corresponding to each syntax node. At the same time, the index between each syntax node is established so that each syntax node business class can contain other syntax node business classes. Since the syntax node contains its parent syntax node business class, the index of the parent syntax node business class can be directly accessed.

[0040] More often, the business classes corresponding to the contract file include compilation control statements, contract import statements, and contract definitions. Among them, the main idea of ​​recursively establishing business classes defined by various contract members in the contract definition has not changed much. However, in the entire recursive process, the syntax extraction method of the statement block is somewhat different as a special business class. When extracting the syntax of the block, it is necessary to extract the business class corresponding to the statement and the business class corresponding to the expression. First, it is necessary to create the corresponding business class according to the type of statement or expression, and then traverse.

[0041] In step S12, since the syntax node information is used as a member of the business class corresponding to the syntax node when constructing the index, each business class can call the syntax filling algorithm to fill the corresponding field describing the syntax information in the business class according to the syntax node information corresponding to its own node. At the same time, in the process of filling the syntax information, the type of the variable and the scope of the variable are determined.

[0042] More specifically, calling the syntax filling algorithm to fill in the syntax information of the current first business class includes at least one of the following: such as compiled version, contract import, contract definition, enumeration definition, structure definition, function definition, library definition, modifier definition, variable name, variable visibility, statement block, code statement, expression, etc.

[0043] In step S13, since a new business class of contract import information is created in step S11, and the syntax node information of the import statement is filled in step S12, according to the C3 inheritance law followed by the Solidity contract multi-inheritance mechanism, the MRO algorithm is used to sort the inheritance order of the contract and obtain the inheritance line information of the contract, thereby providing support for finding a state variable definition or function definition in the contract in the subsequent expression tracing.

[0044] In more embodiments, the above calling methods all start traversal from the root syntax node SourceUnit of the parse tree.

[0045] Figure 2 for Figure 1 A flow chart of a preferred embodiment of the method shown. Figure 2 As shown, in this embodiment, calling the first indexing algorithm to construct the first service class corresponding to the current syntax node includes:

[0046] S110, determine whether the current syntax node has a child syntax node:

[0047] If yes, the first service class is constructed according to the current syntax node information and the second language service class.

[0048] Specifically, as shown in Figure 3, an application scenario of a business class is constructed. From the abstract syntax tree, it can be seen that the function definition (functionDefinition) syntax node is composed of a function keyword (function), a function name identifier (identifier), a function input parameter list (parameterList), a modifier list (modifierList), a return parameter (returnParameters), and a statement block (block).

[0049] When grammar extraction is used to build indexes, only grammar node business classes are recursively built for grammar nodes with child nodes; assuming that the upper-level grammar node calls the indexing method, builds the function definition grammar node business class (FunctionDefinitionInfo), and calls the indexing method to build business classes for the lower-level grammar nodes; the function name identifier (identifier) ​​and the function parameter list (parameterList) in the child nodes of the function definition have child grammar nodes, so their corresponding grammar node business classes are built, namely the identifier business class (IdentifierInfo) and the parameter list business class (parameterListInfo). When these business classes are built, the grammar information (Context) of the grammar node and the function definition business class (FunctionDefinitionInfo) reference are used as parameters and passed into the constructor of the business class. After these grammar node business classes are built, the references of these business classes will be saved in the function definition business class. Then the indexing algorithm is called to recursively build the lower-level grammar node index downward. Until the grammar node is encountered as a terminal node (TeminalNode), that is, a grammar node without child nodes.

[0050] For example, for the child node function parameter list (parameterList) of the function definition syntax node (FunctionDefinition), the function list syntax node information (ParameterListContext) and the reference of the parent syntax node business class (FunctionDefinitonInfo) are passed into the constructor to build the function parameter list business class (ParameterListInfo).

[0051] Figure 4 for Figure 1 The flowchart of a preferred embodiment of the method is shown in FIG. Figure 4 As shown, in this embodiment, the step S12 of simultaneously completing the type tracing of the variable and determining the scope of the variable includes:

[0052] S122, determining whether the current syntax node contains a syntax node for defining a variable: if yes, traversing upward from the current syntax node to obtain type information of the variable;

[0053] S123: Copy and store the first variable type table of the parent syntax node business class of the current syntax node business class as the second variable type table of the current syntax node, and update the variable definition types contained in the current syntax node according to the second variable type table.

[0054] Specifically, a variable list in the current context is established in each function and statement block. The specific method is to detect whether the statement is related to the variable definition before filling in the syntax; for example, when filling in the function definition, it is necessary to first read the definition information of the state variable in the parent node, and then read its own function input parameter definition information and function return value definition information; when filling in the block syntax node information, the block needs to copy a variable list from the parent node, and then fill the new variable definition into the copied variable list according to the statement type defined in the block. When a new block appears recursively afterwards, the same method is used. If a variable with the same name appears, the previous definition is overwritten in the current syntax node.

[0055] Figure 5 for Figure 1 A flowchart of a preferred implementation of step S13 in the method shown. Figure 5 As shown, in this embodiment, step 13 includes:

[0056] S131. Obtain the direct inheritance information of each contract according to the contract definition information filled by the calling syntax filling algorithm, that is, which contracts the current contract directly inherits, which are specified in the inheritanceSpecifier of the contract, and finally obtain all the contract information inherited by each contract;

[0057] S132, when performing expression tracing, if the current expression node contains a syntax node at the next level, determine its child expression node information, and determine the type information of the current expression according to the result of the operation;

[0058] S133, calling the expression type tracing method of the newly created sub-grammar node according to the index relationship, so that the current expression business class recursively fills the next layer of expression type information until all expressions in the contract are determined to have specific types.

[0059] Specifically, starting from the root node, recursively trace the expressions of all syntax node business classes containing expressions. The final recursive base of all expression tracing is the primary expression. When tracing the type of the primary expression, the definition information of the variable can be found from the current block variable list or function keyword variable list of the expression, the current contract, and the parent contract to obtain the type of the primary expression; after filling in the type of the primary expression, backtrack, and determine the type of the current expression according to the type of the sub-expression and the operation type of the expression.

[0060] by Figure 6 Take an example to illustrate the backtracking process of expression tracing.

[0061] For the expression h=(a+b)*c>0? (d>e):(f==g), a, b, and c in the expression are of int type, d and e are of uint type, both of which are of byte type, and h is of bool type. h is an identifier representing a bool type variable. At this point, the expression has been traced back to the leaf node, and the expression h is determined to be of bool type by backtracking to the upper level.

[0062] According to ANTLR rules, this expression can be parsed as Figure 6 The expression tree is the root node of the whole tree. According to the rules, it is first parsed as an assignment statement, and the expression h is assigned. The calculation result of the expression (a+b)*c>0? (d>e):(f==g) is assigned to the expression h.

[0063] First, expression h is traced. Expression h is an identifier and is of bool type. At this time, the expression traceback reaches the leaf node and the recursive base. It traces back to the previous level to determine that expression h is of bool type.

[0064] When performing expression tracing on the expression (a+b)*c>0? (d>e):(f==g), which is a ternary operation expression, if the conditional expression (a+b)*c>0 on the left side of ? is satisfied, the expression result is the operation result on the left side of the colon (d>e), otherwise it is the operation result on the right side of the colon (f==g).

[0065] Recursively trace back these three expressions. The specific steps are:

[0066] For the expression (a+b)*c>0 on the left side of the question mark, this expression is a comparison operation expression. The left side of the greater than sign is an operation expression, and the right side is 0, so it can be determined that the type is an integer. The expression (a+b)*c on the left side is a multiplication expression. The left side is the (a+b) bracket expression, and the right side is the variable c, which determines that c is an integer. The bracket expression (a+b) on the left indicates the priority of the operation. The type of this expression is determined by the type of the a+b expression. a+b is an addition expression, the type of a is int, and the type of b is int. At this time, the leaf node is reached, there is no child node that can be recursively returned, and it is backtracked to the upper layer. Then the result of a+b is int type, the result of (a+b) is int type, the result of (a+b)*c is int type, and the result of (a+b)*c>0 is bool type.

[0067] For the bracket expression (d>e) on the left side of the colon, the expression type is determined by the expression d>e; d>e is a comparison operation expression, the type of d is uint, and the type of e is uint. At this point, the root node is reached, there is no child node that can be recursively traced back to the previous level. Then the operation result of d>e is of type bool, and the operation result of (d>e) is of type bool.

[0068] Similarly, for the parenthesized expression (f==g) on ​​the right side of the colon, the expression type is determined by the expression f==g; f==g is a comparison operation expression, the type of f is byte, and the type of g is byte. At this point, the root node is reached, and there is no child node to recurse to, so backtrack to the previous level. Then the operation result of f==g is of type bool, and the operation result of (f==g) is of type bool.

[0069] In this way, when we trace back to the three expressions (a+b)*c, (d>e), and (f==g), the type of the expression (a+b)*c>0? (d>e):(f==g) can be determined to be bool. Finally, we trace back to the entire expression h=(a+b)*c>0? (d>e):(f==g), and determine that the expression is of bool type, thus completing the corresponding expression tracing.

[0070] Figure 7 A schematic diagram of the structure of a device provided in one embodiment of the present invention.

[0071] like Figure 7 As shown, as another aspect, the present application also provides a device 600, including one or more central processing units (CPU) 601, which can perform various appropriate actions and processes according to the program stored in the read-only memory (ROM) 602 or the program loaded from the storage part 608 to the random access memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the device 600 are also stored. The CPU 601, the ROM 602, and the RAM 603 are connected to each other via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0072] The following components are connected to the I / O interface 605: an input section 606 including a keyboard, a mouse, etc.; an output section 607 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 608 including a hard disk, etc.; and a communication section 609 including a network interface card such as a LAN card, a modem, etc. The communication section 609 performs communication processing via a network such as the Internet. A drive 610 is also connected to the I / O interface 605 as needed. A removable medium 611, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 610 as needed, so that a computer program read therefrom is installed into the storage section 608 as needed.

[0073] In particular, according to an embodiment of the present disclosure, any of the above embodiments describes a method for extracting grammatical information based on a Solidity smart contract.

[0074] A computer program product, comprising a computer program tangibly contained on a machine-readable medium, the computer program comprising program code for executing a method for extracting grammatical information based on a Solidity smart contract. In such an embodiment, the computer program can be downloaded and installed from a network through a communication portion 609, and / or installed from a removable medium 611.

[0075] As another aspect, the present application also provides a computer-readable storage medium, which may be a computer-readable storage medium included in the apparatus of the above embodiment; or a computer-readable storage medium that exists independently and is not assembled into the device. The computer-readable storage medium stores one or more programs, which are used by one or more processors to execute the extraction method described in the present application.

[0076] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be realized by a dedicated hardware-based system that performs a specified function or operation, or can be realized by a combination of dedicated hardware and computer instructions.

[0077] The units or modules involved in the embodiments described in the present application may be implemented by software or by hardware. The units or modules described may also be arranged in a processor. For example, each of the units may be a software program arranged in a computer or a mobile smart device, or may be a separately configured hardware device. The names of these units or modules do not, in some cases, constitute limitations on the units or modules themselves.

[0078] The above description is only a preferred embodiment of the present application and an explanation of the technical principles used. Those skilled in the art should understand that the scope of the invention involved in the present application is not limited to the technical solution formed by a specific combination of the above technical features, but should also cover other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the concept of the present application. For example, the above features are replaced with the technical features with similar functions disclosed in the present application (but not limited to) to form a technical solution.

Claims

1. A method for extracting grammatical information based on Solidity smart contract, characterized in that: include: Calling a first indexing algorithm to construct a first service class corresponding to the current grammar node and saving an index relationship of grammar information of the current grammar node in a second service class of a parent node of the current node; Repeat the above calling steps to establish a corresponding grammar business class for the child node until a leaf grammar node appears, wherein the construction parameters of the first business class include the grammar information of the current grammar node and the second business class; Calling a syntax filling algorithm to fill the syntax information of the current first business class, and completing the type tracing of the variable and determining the scope of the variable at the same time; calling the next layer of syntax node business class to fill the syntax information corresponding to the next layer of business class until all business classes are filled; the simultaneous completion of the variable type tracing and the determination of the variable scope includes: Determine whether the current syntax node contains a syntax node for variable definition: if yes, traverse upward from the current syntax node to obtain the type information of the variable; Copying and storing the first variable type table of the parent syntax node service class of the current syntax node service class as the second variable type table of the current syntax node, and updating the variable definition types contained in the current syntax node according to the second variable type table; Sort the inheritance order of the contracts to obtain the inheritance line information of each contract so as to accurately trace the expression types in the contract, including: Obtain the direct inheritance information of each contract according to the contract definition information filled in by the calling syntax filling algorithm, that is, which contracts the current contract directly inherits, specified in the inheritanceSpecifier of the contract, and finally obtain all the contract information inherited by each contract; When performing expression tracing, if the current expression node contains the next-level syntax node, its sub-expression node information is determined, and the type information of the current expression is determined based on the result of the operation; The expression type tracing method of the newly created sub-grammar node is called according to the index relationship, so that the current expression business class recursively fills the next layer of expression type information until all expressions in the contract are determined to have specific types.

2. The method according to claim 1, characterized in that Calling the first index algorithm to construct the first service class corresponding to the current syntax node includes: Determine whether the current syntax node has a child syntax node: If yes, construct the first service class according to the current syntax node information and the second service class.

3. The method according to claim 1 or 2, characterized in that: The corresponding operations of calling the first indexing algorithm and calling the grammar filling algorithm are both executed recursively from the root node of the grammar tree.

4. The method according to claim 1, characterized in that: The calling syntax filling algorithm fills the syntax information of the current first business class including at least one of the following: compiled version, contract import, contract definition, enumeration definition, structure definition, function definition, library definition, modifier definition, variable name, variable visibility, code block, code statement, expression.

5. The method according to claim 1, characterized in that Apply the C3 inheritance method followed by the Solidity contract multi-inheritance mechanism, use the MRO algorithm to sort the inheritance order of the contract, and obtain the inheritance line information of the contract.

6. An electronic device, characterized in that: The device comprises: one or more processors; a memory for storing one or more programs, When the one or more programs are executed by the one or more processors, the one or more processors are caused to perform the method according to any one of claims 1 to 5.

7. A storage medium storing a computer program, characterized in that: When the program is executed by a processor, the method according to any one of claims 1 to 5 is implemented.

Images