KR102529028B1 - Method And Apparatus for Generating Proxy Contract - Google Patents

Abstract

This disclosure provides a method and apparatus for generating a proxy contract. According to one aspect of the present disclosure, a proxy contract creation method that ensures that each execution flow does not cause state inconsistency by creating a proxy contract that performs a state inconsistency check using execution cost and/or stack size required for an execution flow. and devices.

Description

Proxy contract generation method and device {Method And Apparatus for Generating Proxy Contract}

The present disclosure relates to a method and apparatus for generating a proxy contract. The present disclosure is derived from research conducted as part of the development of modular library and engine technology for block chain emulation by the Ministry of Science and ICT. [Task identification number: 2020-0-00191, task title: Development of modular library and engine technology for blockchain emulation]

The contents described in this part merely provide background information on the present embodiment and do not constitute prior art.

Recently, services based on DApp (Decentralized Application, DApp) are increasing. A DApp is a decentralized application that provides services using blockchain technology, ensuring the data integrity of on-chain data. Among the services provided based on DApp, there are services based on multiple on contracts.

Multiple smart contracts refer to smart contracts configured to access data of other smart contracts according to data access rights. A smart contract is a contract concluded and executed in a blockchain environment. When a node on the blockchain network satisfies the conditions for signing a smart contract, the smart contract is concluded and the code of the smart contract is executed. Executing the code of these smart contracts requires an execution cost (e.g. gas in Ethereum). State information on the contents of the smart contract and whether or not it has been signed becomes on-chain data of the blockchain network and data integrity can be guaranteed.

In order for DApp to provide services based on multiple smart contracts, a flexible execution flow (control flow or execution flow) on-chain must be supported. For example, error handling for the changed execution flow using low-level API (eg delegate call) should be supported. If proper error handling is not performed in the execution of the smart contract, the transaction is treated as normally terminated even though the command was not executed correctly, and a state inconsistency problem may occur.

1 is an exemplary diagram of a scenario in which state inconsistency occurs in an environment based on multiple smart contracts.

When a user node generates a transaction to satisfy the contract condition of smart contract Z, the code of smart contract Z is executed. Smart contract Z calls smart contract A, causing smart contract A's code to be executed. Then, smart contract Z calls smart contract B through low-level API. Since smart contract B calls smart contract B through low-level API, smart contract Z does not include exception handling for calls from smart contract B. Therefore, even if smart contract B is not executed successfully and exception processing is performed, smart contract Z treats the contract as normally executed, and the transaction requested by the user node is recorded as successfully executed on the blockchain, and the blockchain network pays the execution cost according to the execution of the code from the user node.

This state inconsistency problem occurs when the execution cost for executing each execution flow of the code is insufficient, the stack space required to execute the changed execution flow exceeds the available stack space, or the exception handling of the changed execution flow occurs in the absence of Once an erroneous transaction state is stored in the blockchain, the error cannot be corrected afterwards, and replacing the smart contract with a new smart contract is costly.

Therefore, it is necessary to devise a method to prevent the state inconsistency problem while maintaining code invariance so that DApp can stably provide services to users.

According to one aspect of the present disclosure, a proxy contract creation method that ensures that each execution flow does not cause state inconsistency by creating a proxy contract that performs a state inconsistency check using execution cost and/or stack size required for an execution flow. And there is a main purpose to provide a device.

According to one aspect of the present disclosure, in a method for generating a proxy contract by a proxy contract generator, the process of extracting a call-flow from the code of a smart contract; A process of receiving an execution cost required for execution of a first execution flow, which is any one of the extracted execution flows, and/or a stack size required for execution of the first execution flow; and generating a proxy contract that performs a state inconsistency check based on the execution cost and/or the stack size.

According to one aspect of the present disclosure, an extraction module for extracting a call-flow from the smart contract code; An input module that receives, from a node, an execution cost required for execution of a first execution flow, which is any one of the extracted execution flows, and/or a stack size required for execution of the first execution flow; and a generating module generating a proxy contract that performs a state inconsistency check based on the execution cost and/or the stack size.

According to one aspect of the present disclosure, by creating a proxy contract that performs a state inconsistency check using the execution cost and / or stack size required for the execution flow, there is an effect of ensuring that each execution flow does not cause state inconsistency. .

Accordingly, in the case of using the proxy contract creation method and device, vulnerabilities are protected without changing the code of the smart contract currently in service, preventing users from paying execution costs for abnormally performed transactions, and service providers It has the effect of identifying vulnerabilities and responding appropriately.

The effects of the present disclosure are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

1 is an exemplary diagram of a scenario in which state inconsistency occurs in an environment based on multiple smart contracts.
2 is a block diagram showing an apparatus for generating a proxy contract according to an embodiment of the present disclosure.
3 is an exemplary view illustrating a method of extracting an execution flow according to an embodiment of the present disclosure.
4 is a flowchart illustrating a process of performing a proxy contract creation method according to an embodiment of the present disclosure and applying the proxy contract creation method.

Hereinafter, some embodiments of the present disclosure will be described in detail through exemplary drawings. In adding a reference code to the components of each drawing, it should be noted that the same components have the same numbers as much as possible even if they are displayed on different drawings. In addition, in describing the present disclosure, if it is determined that a detailed description of a related known configuration or function may obscure the gist of the present disclosure, the detailed description will be omitted.

In addition, in describing the components of the present disclosure, terms such as second and first may be used. These terms are only used to distinguish the component from other components, and the nature, order, or order of the corresponding component is not limited by the term. Throughout the specification, when a part 'includes' or 'includes' a certain component, it means that it may further include other components without excluding other components unless otherwise stated. . In addition, the '... Terms such as 'unit' and 'module' refer to a unit that processes at least one function or operation, and may be implemented as hardware, software, or a combination of hardware and software.

The detailed description set forth below in conjunction with the accompanying drawings is intended to describe exemplary embodiments of the present disclosure, and is not intended to represent the only embodiments in which the present disclosure may be practiced.

This disclosure is a proxy contract that guarantees that state inconsistency in contract execution does not occur based on the execution cost and stack slot length required for the execution of each control flow of the smart contract. contract) generation method and device are disclosed.

A proxy contract is a smart contract that allows the user to request execution (function call or command) to be executed by the logic of a specific logic contract. The proxy contract may include a fallback function including delegateCall in order to transfer the requested call to a logic contract or smart contract without modification.

Although the present disclosure describes an Ethereum environment as an example, the proxy contract creation method and computer program for the present disclosure do not necessarily have to be performed only in the Ethereum environment as a blockchain environment. For example, the proxy contract creation method and device of the present disclosure can be applied to a blockchain environment (eg, a blockchain 2.0 or higher environment) that supports smart contracts and requires execution costs for each execution flow of code.

2 is a block diagram showing an apparatus for generating a proxy contract according to an embodiment of the present disclosure.

The proxy contract generating device 200 according to an embodiment of the present disclosure includes all or part of an extraction module 202, an input module 204, and a generation module 206. The proxy contract generating device 200 shown in FIG. 2 is according to an embodiment of the present disclosure, and all components shown in FIG. 2 are not essential components, and some components may be added, changed, or deleted in other embodiments. can For example, in another embodiment, the proxy contract generator predicts the execution cost required for execution flow and/or the stack slot size required for execution flow, and transmits it to the input module (prediction module (not shown)) may further include.

2 shows the proxy contract generator 200 as a device, but this is for convenience of explanation. In another embodiment, the proxy contract generator is a software module or processor that performs the functions of each component 202 to 206. can be implemented

The extraction module 202 extracts the call-flow from the code of the smart contract. To extract the execution flow, the extraction module 202 may create an Abstract Syntax Tree (AST) for the code of the smart contract. Here, the abstract syntax tree is a tree-type data structure representing an abstract syntax structure of source code. The extraction module 202 may further extract a call-graph for the abstract syntax tree generated for the code of the smart contract, and extract individual execution flows according to the execution of the code. Here, the call graph is a graph of an execution flow showing a call relationship between subroutines of a program. A specific example of extracting an execution flow using an abstract syntax tree and a call graph will be described later with reference to FIG. 3 .

With respect to the execution flow extracted by the extraction module 202, the input module 204 receives an execution cost required for execution of the execution flow and/or a stack size required for execution of the execution flow from a separate user or a separate device. . Here, a separate user or a separate device may refer to a service developer/service provider of DApp (Decentralized Applicatoin) that provides smart contract-based services, or a device used by such service developer or service provider to provide services. there is. Here, input refers to a case in which a user inputs an execution cost and/or a stack size using an input device as well as a case in which a user receives and obtains an execution cost and/or a stack size using a wired/wireless communication means of a user terminal. can include all In addition, input by a separate device may include, for example, both input using an input device or input using wired or wireless communication means. The execution cost and/or the stack size input to the input module 204 may be a value (or a range value) predicted by a separate user or a separate device.

In a blockchain environment, execution of smart contract code (or execution flow) is performed by any node on the blockchain network. Accordingly, in the present disclosure, the meaning of execution cost required for execution of an execution flow means a fee (or a value of resources consumed by execution such as computing power) according to execution of code (or execution of execution flow). In the Ethereum environment, gas corresponding to the number of times the code is executed is provided to any node that executes the code. A node requesting a transaction can request a transaction by presenting a certain Gwei and gas limit, and any node executing the code will only perform work within the gas limit. Accordingly, the input module 204 may receive gas limit and Gwei or gas as an execution cost.

The input module 204 may receive a maximum execution cost and/or a minimum execution cost required for execution of the execution flow as an execution cost. When the input module 204 receives only the maximum execution cost as the execution cost, the proxy contract judges whether the execution flow is executed within the input maximum execution cost range from 0 (the unit may vary depending on each blockchain environment) to state Inconsistency checks can be performed. If the execution of the execution flow exceeds the maximum execution cost, the proxy contract determines that a state inconsistency has occurred. When the input module 204 receives only the minimum execution cost as the execution cost, the proxy contract can perform a state inconsistency check by determining whether the execution flow is executed with a value higher than the input minimum execution cost. If the execution of the execution flow is performed at less than the minimum execution cost, the proxy contract determines that a state inconsistency has occurred.

When the input module 204 receives the minimum execution cost and the maximum execution cost as the execution cost, the proxy contract can perform a state inconsistency check by determining whether the execution flow is executed within the range of the minimum execution cost and the maximum execution cost.

When an arbitrary node executes smart contract code (or execution flow), stack memory for storing variables and the like is required. Accordingly, in the present disclosure, the meaning of the stack size required for execution of an execution flow means the size (or size) of memory used for execution of code (or execution of execution flow). The Ethereum Virtual Machine (EVM) can provide, for example, as much stack space as 1024 256-bit stacks. Accordingly, the input module 204 may receive the stack slot size (or the number of stack slots) as the stack size. In this case, the proxy contract executes the execution flow and determines that state inconsistency has occurred when the required stack slot size exceeds the stack slot size inputted by the input module 204.

The creation module 206 uses the execution cost and/or stack size input by the input module 204 to create a proxy contract that performs state inconsistency check. The generation module 206 may generate a proxy contract that checks whether a cost required in an actual execution process of an execution flow is included in a range of an input execution cost, for example, as a state inconsistency check. Alternatively, the generation module 206 may generate a proxy contract that checks whether the stack size required in the actual execution process of the execution flow is less than or equal to the input stack size as a state inconsistency check.

The generation module 206 also checks whether the cost required in the actual execution process of the execution flow is included in the range of the input execution cost and the size of the stack required in the actual execution process of the execution flow. You can create a proxy contract that each checks whether it is less than or equal to the stack size.

Table 1 is pseudo code that checks whether the cost required in the actual execution process of the execution flow is included in the range of the input execution cost and whether the stack size required in the actual execution process of the execution flow is less than or equal to the input stack size. shows an example of

function check (inputSize, inputGas){
if(checkStack(inputSize, 0) && checkGas(inputGas)){
(bool success,) = delegatecall();
if(!success) revert();
}else revert();
}

function checkStack(requiredSize, count) {
if (0<=count && count < requiredSize)
return checkStack(requiredSize, count+1);
else false;
}

function checkGas(requiredGas) public {
if (gasleft >= requiredGas)
return true;
else false;
}
}

Referring to Table 1, the check function included in the proxy contract executes the checkStack and checkGas functions respectively to perform the execution flow. The check function executes the execution flow by calling the delegatecall function when both the checkStack and checkGas functions return true, that is, when it is judged that no state mismatch has occurred. The check function calls the revert function to abort the execution of the execution flow and restore the change when either of the checkStack and checkGas functions return a false value, that is, when it is determined that a state inconsistency has occurred.

The checkStack function in Table 1 receives inputSize, which is the stack size input from a separate device or a separate user, as the value of the input parameter requiredSize, and returns whether or not the currently used stack is less than or equal to inputSize. The checkGas function in Table 1 receives inputGas, an execution cost input from a separate device or a separate user, as the value of the input parameter requiredGas, and returns whether the remaining gas amount (return value of the gasleft function) is greater than or equal to inputGas.

3 is an exemplary view illustrating a method of extracting an execution flow according to an embodiment of the present disclosure.

The “smart contract code” in FIG. 3 is an exemplary code of a smart contract to be executed. The proxy contract generator generates the "abstract syntax tree" of FIG. 3 as an abstract syntax tree for the "smart contract code" of FIG. The “Abstract Syntax Tree” in FIG. 3 is an execution flow when executing the “smart contract code” in FIG. 3 and shows the call relationship between functions. For example, when the "blog" function is called, the "blogMeta" function is called, and when the "blogMeta" function is called, the "setWriter" function is called. In this way, in the call relationship between each function or variable, the abstract syntax tree refers to a function or variable that is called beforehand as a parent node, and a function or variable that is called or declared by a parent node as a child node. ).

The proxy contract generator may extract the “call graph” of FIG. 3 from the abstract syntax tree in order to extract the execution flow to be performed at the current stage. Since the “call graph” in FIG. 3 is for the execution flow in which the “setWriter” function calls the “calcMoney” function, the proxy contract generator converts the execution flow in which the “setWriter” function calls the “calcMoney” function to the proxy contract. Extract as object to create.

4 is a flowchart illustrating a process of performing a proxy contract creation method according to an embodiment of the present disclosure and applying the proxy contract creation method.

A transaction for the smart contract occurs on the blockchain network, and the smart contract is executed (S400). The execution of the smart contract in step S400 does not mean that all execution flows of the smart contract are completed, as it means that the execution command of the smart contract is executed. The blockchain network can cause the proxy contract creation device to first create a proxy contract according to the execution command of the smart contract. This is to ensure that each execution flow of the smart contract is executed while the state inconsistency check is performed by the proxy contract.

The proxy contract generator generates an AST for the code of the smart contract (S402).

The proxy contract generator extracts the execution flow by extracting the call graph included in the AST (S404).

The proxy contract generating device calculates the execution cost and/or the stack size (or stack slot size, omitted below) required to execute the execution flow from a node on the blockchain network, a separate user, or a separate device. Input is received (S406). Herein, the input includes both a case where the execution cost and/or the stack size is input through an input device and a case where the execution cost and/or the stack size are received and obtained through wired/wireless communication. The input cost and/or stack size may be a value predicted by a node, a separate user, or a separate device (or a value of a category).

The proxy contract generating device creates a proxy contract that performs a state inconsistency check using the input execution cost and/or stack size (S408).

For the execution flow extracted in step S404, a proxy contract is executed on the blockchain network (S409). The proxy contract runs the execution flow extracted in step S404, and determines whether the status is inconsistent with respect to the cost and/or used stack size during the execution process.

During the execution of step S409, the proxy contract determines whether state inconsistency occurs (S410). For example, the proxy contract determines in real time whether the execution cost and / or stack size required while executing the execution flow exceeds the execution cost and / or stack size input in step S406, and determines whether the state is inconsistent. .

If it is determined that a state inconsistency has occurred in step S410, the blockchain network fails the requested transaction (S412). For example, when a proxy contract returns a return value indicating failure processing, any node on the blockchain network can record the transaction failure status in the block of each node.

If it is determined that state inconsistency has not occurred in step S410, any node on the blockchain network determines whether the entire code of the smart contract has been executed in order to execute the next execution flow (S420). However, when it is determined that state inconsistency does not occur in step S410, steps S420 to S422 are omitted, and the entire procedure may end after the execution flow is executed.

If it is determined that the entire code has been executed in step S420, the blockchain network successfully processes the transaction (S422). For example, any node on the blockchain network can record the status of a successful transaction in the block of each node.

If it is determined that the entire code has not been executed in step S420, any node on the blockchain network causes the proxy contract generator to execute step S404 again. As a result, the proxy contract generator can create a proxy contract for the next execution flow.

On the other hand, if it is not necessary to create a proxy contract for the entire execution flow of the smart contract, step S420 can be replaced with a process of determining whether all codes of a preset category have been executed.

In another embodiment, steps S402 to S408 may be performed only when a low-level call occurs.

In FIG. 4, it is described that each process is sequentially executed, but this is merely an example of the technical idea of an embodiment of the present disclosure. In other words, those skilled in the art to which an embodiment of the present disclosure pertains may change and execute the sequence described in FIG. 4 or perform one or more of each process without departing from the essential characteristics of the embodiment of the present disclosure. Since it can be applied by various modifications and variations by executing in parallel, it is not limited to the time-sequential order of FIG. 4 .

Various implementations of devices, units, processes, steps, etc. described herein may include digital electronic circuits, integrated circuits, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), computer hardware, firmware, software, and/or combinations thereof. These various implementations may include being implemented as one or more computer programs executable on a programmable system. A programmable system includes at least one programmable processor (which may be a special purpose processor) coupled to receive data and instructions from and transmit data and instructions to a storage system, at least one input device, and at least one output device. or may be a general-purpose processor). Computer programs (also known as programs, software, software applications or code) contain instructions for a programmable processor and are stored on a “computer readable medium”.

A computer-readable recording medium includes all kinds of recording devices that store data that can be read by a computer system. These computer-readable 　recording media include non-volatile or non-transitory storage devices such as ROM, CD-ROM, magnetic tape, floppy disk, memory card, hard disk, magneto-optical disk, and storage device. It may further include a medium. In addition, the computer-readable recording medium may be distributed in computer systems connected through a network, and computer-readable codes may be stored and executed in a distributed manner.

Various implementations of the systems and techniques described herein may be implemented by a programmable computer. Here, the computer includes a programmable processor, a data storage system (including volatile memory, non-volatile memory, or other types of storage systems, or combinations thereof) and at least one communication interface. For example, a programmable computer may be one of a server, network device, set top box, embedded device, computer expansion module, personal computer, laptop, personal data assistant (PDA), cloud computing system, or mobile device.

The above description is merely an example of the technical idea of the present embodiment, and various modifications and variations can be made to those skilled in the art without departing from the essential characteristics of the present embodiment. Therefore, the present embodiments are not intended to limit the technical idea of the present embodiment, but to explain, and the scope of the technical idea of the present embodiment is not limited by these embodiments. The scope of protection of this embodiment should be construed according to the claims below, and all technical ideas within the scope equivalent thereto should be construed as being included in the scope of rights of this embodiment.

200: proxy contract generator
202: extraction module
204: input module
206: generation module

Claims (9)

In the method in which the proxy contract generator creates a proxy contract,
The process of extracting the call-flow from the code of the smart contract;
A process of receiving an execution cost required for execution of a first execution flow, which is any one of the extracted execution flows, and/or a stack size required for execution of the first execution flow; and
Creating a proxy contract that performs a state inconsistency check based on the execution cost and/or the stack size,
The execution cost is the maximum execution cost and / or minimum execution cost required for the execution of the first execution flow,
How to create a proxy contract. According to claim 1,
The process of extracting the execution flow,
A proxy contract creation method, performed by generating an abstract syntax tree for the code. According to claim 2,
The process of extracting the execution flow,
Proxy contract creation method, performed by extracting a call-graph of the abstract syntax tree. delete According to claim 1,
The process of creating the proxy contract,
As the state inconsistency check, the proxy contract is created to check whether a cost required in an actual execution process of the first execution flow is included in a range of the execution cost. According to claim 1,
The process of creating the proxy contract,
As the state inconsistency check, the proxy contract is created to check whether a stack size required in an actual execution process of the first execution flow is less than or equal to the stack size. According to claim 1,
The process of creating the proxy contract,
As the state inconsistency check, it is determined whether a cost required in the actual execution process of the first execution flow is included in the range of the execution cost, and a stack size required in the actual execution process of the first execution flow is the stack size. A method for creating a proxy contract, wherein the proxy contract is created to check whether it is less than or equal to. A computer program stored in a computer-readable recording medium to execute each process included in the proxy contract creation method according to any one of claims 1 to 3 and 5 to 7. An extraction module that extracts a call-flow from the smart contract code;
An input module that receives, from a node, an execution cost required for execution of a first execution flow, which is any one of the extracted execution flows, and/or a stack size required for execution of the first execution flow; and
A generation module for generating a proxy contract that performs a state inconsistency check based on the execution cost and/or the stack size,
The execution cost is the maximum execution cost and / or minimum execution cost required for the execution of the first execution flow,
A proxy contract generator.

Images