CN111563237B - Intelligent contract security enhancement method - Google Patents
Intelligent contract security enhancement method Download PDFInfo
- Publication number
- CN111563237B CN111563237B CN202010211696.8A CN202010211696A CN111563237B CN 111563237 B CN111563237 B CN 111563237B CN 202010211696 A CN202010211696 A CN 202010211696A CN 111563237 B CN111563237 B CN 111563237B
- Authority
- CN
- China
- Prior art keywords
- jump
- address
- intelligent contract
- byte
- byte code
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 30
- 238000010586 diagram Methods 0.000 claims abstract description 13
- 238000003780 insertion Methods 0.000 claims abstract description 5
- 230000037431 insertion Effects 0.000 claims abstract description 5
- 230000006870 function Effects 0.000 claims description 7
- 230000002708 enhancing effect Effects 0.000 claims description 4
- 238000004364 calculation method Methods 0.000 claims description 3
- 238000004458 analytical method Methods 0.000 abstract description 12
- 238000005516 engineering process Methods 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000009395 breeding Methods 0.000 description 1
- 230000001488 breeding effect Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000035772 mutation Effects 0.000 description 1
- 238000003909 pattern recognition Methods 0.000 description 1
- 108090000623 proteins and genes Proteins 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
- G06F21/14—Protecting executable software against software analysis or reverse engineering, e.g. by obfuscation
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention provides an intelligent contract security enhancement method, and relates to the technical field of block chain intelligent contract security. Firstly, restoring a control flow diagram of intelligent contract byte codes, and marking destination addresses of JUMP of all JUMP/JUMP PI instructions, positions of JUMP/JUMP PI instructions and front-back position relations between the JUMP destination addresses and the JUMP instructions; searching a position capable of inserting the replacement byte code in the original byte code of the intelligent contract and marking the address of the insertion position; generating basic replacement byte codes according to the selected different address confusion modes; reconstructing all jump addresses and jump instructions in the basic replacement byte codes and the original byte codes, and recovering a control flow diagram of the byte codes; and inserting the mixed jump address into the replacement byte code, and inserting the replacement byte code into the original byte code to generate a new intelligent contract byte code. The method can disable the analysis work of the common intelligent contract reverse analysis tool and increase the security of the contract.
Description
Technical Field
The invention relates to the technical field of intelligent contract security of a blockchain, in particular to an intelligent contract security enhancement method.
Background
With the widespread acceptance of the unique decentralization, non-tamper-resistance and openness of blockchain technologies, more and more people are beginning to use blockchain technologies as the underlying framework supporting the fields of finance, supervision, gaming, etc., to achieve a high convergence of internet technologies and financial values. In order to meet the demands of users in more scenes, the blockchain supports deployment and operation of intelligent contracts, provides a complete environment for the execution of the intelligent contracts, and can call the intelligent contracts through transactions to complete a series of operations required by the users. Because of the openness and non-tamper ability of the blockchain, all intelligent contracts deployed on the blockchain are publicly visible and the outcome of execution of the transaction is deterministic. This feature results in the smart contract failing to perform functions such as generating random numbers, which is critical to gaming and financial applications. For example, cryptoKitties is a popular game in the Ethermill where players can breed and trade digital kittens, which would be of higher value by the rare genome combination. The game development team uses a closed source smart pool to introduce random numbers for reproduction of kittens in order to ensure randomness of inheritance and mutation. Nevertheless, researchers claim that smart contracts for cryptokittens can be analyzed in reverse using Erays to greatly increase the probability of breeding high value kittens, undoubtedly in a way that disrupts game randomness and reduces the value of kittens possessing rare genes. In addition to generating random numbers, some smart contract developers set contracts as closed sources for security reasons to prevent an attacker from analyzing deployed contract bytecodes, but may still analyze the functionality of the contract code using smart contract decompiling tools such as Vandal, gigahorse, causing significant loss to developers and users of smart contracts.
While developers have urgent demands for anti-reverse analysis techniques for smart contract bytecodes, there is currently no effective method for protecting smart contracts. Because of the special architecture of the smart contract operating environment, existing techniques for reverse analysis on other platforms are ineffective or too expensive for smart contracts. The main difficulties are as follows:
(1) The smart contract virtual machine (hereinafter EVM) is not a standard von neumann system, and when executed in EVM, the contract code is stored in a read-only memory space, not in a readable and writable memory or external memory space as in a conventional computer composition. Therefore, the contract code cannot be modified in the execution process, which means that the conventional code encryption mode cannot be applied in the blockchain.
(2) Invoking execution of the smart contract consumes Gas. Gas is the basic unit in the blockchain that is used to measure the consumption of computing resources by transactions. The more steps a contract performs, the more expensive instructions are executed, and the more Gas is consumed, which can cause additional expense to the user deploying and invoking the contract. Conventional code obfuscation techniques may add a large number of additional instructions to the code, resulting in a significant increase in Gas consumption, which is unacceptable to contract developers and users.
A common intelligent contract reverse analysis tool (Erays, vandal, gigahorse) first restores the control flow graph of the bytecode (Control Flow Graph, CFG for short) when analyzing intelligent contracts, and then restores the bytecode of the intelligent contracts to human readable code or intermediate code representations (Intermediate Representation, IR for short) available to security analysis tools based on the CFG. If the CFG recovery fails, the reverse analysis tool cannot produce the correct analysis result.
Disclosure of Invention
Aiming at the defects of the prior art, the invention provides an intelligent contract security enhancement method, which causes the reverse analysis of the intelligent contract by a reverse tool to fail and realizes the protection of the intelligent contract byte code.
In order to solve the technical problems, the invention adopts the following technical scheme: an intelligent contract security enhancement method, comprising the steps of:
step 1, acquiring an original byte code of an intelligent contract, recovering a control flow diagram of the original byte code of the intelligent contract, and marking destination addresses of all JUMP instructions of the JUMP instructions, a stack-entering instruction of the JUMP instructions, positions of the JUMP instructions and front-back position relations between the JUMP destination addresses and the JUMP instructions;
step 2, searching a position capable of inserting the replacement byte code in the original byte code of the intelligent contract and marking an address of the insertion position;
in the instruction sequences corresponding to the original byte codes of the intelligent contracts, each matched { EQ-PUSH-JUMPI } instruction sequence is used as an object code to be replaced and used for confusing a byte code control flow diagram of the intelligent contracts;
step 3, a user selects any one of four address confusion modes to replace byte codes, and different basic replacement byte codes are generated according to the selected different address confusion modes;
the four address confusion modes are respectively as follows:
address confusion pattern 1: obtaining a jump address using a memory access;
address confusion pattern 2: obtaining a jump address by using storage access;
address confusion pattern 3: obtaining a jump address by calculation using a sha3 () function;
address confusion pattern 4: obtaining a return value as a jump address using an external contract call;
when the user selects address confusion mode 1, the basic replacement byte codes are as follows: "[ x ]604052604051";
when the user selects address confusion mode 2, the basic replacement byte codes are as follows: "[ x ]604055604054";
when the user selects address confusion mode 3, its basic replacement bytecode is:
“60ff6050526001606f20600f1660099004[**][**]02”；
when the user selects address confusion pattern 4, its underlying replacement bytecode is:
“[**][**]61007d60048073bde95422681e4c3984635af2f2f35f8c44a4ddc973ffffffffffffffffffffff ffffffffffffffffff1690602001909190505060008173ffffffffffffffffffffffffffffffffffffffff16638dde08406000604051602001526040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b15156102c65a03f115155050506040518051905090509190505016”；
wherein, [ x ] represents the skip address and the byte code of the push operation instruction which need to be confused;
step 4, reconstructing all jump destination addresses and jump instructions in the basic replacement byte codes and the original byte codes, and recovering a normal control flow diagram of the intelligent contract byte codes;
step 4.1, judging the front-back relation between the destination address of each JUMP/JUMP PI instruction in step 1 and the inserting position address in step 2 in turn, if the JUMP destination address is behind the inserting position, adding the byte length of the inserting code to the JUMP destination address to obtain a new JUMP destination address; otherwise, the destination address of JUMP of the JUMP/JUMP instruction is unchanged;
step 4.2, judging whether the destination address jumped by each JUMP destination address obtained in the step 4.1 is carried or not in sequence, if so, modifying the corresponding push operation instruction according to the length of the new jumped destination address, and meanwhile, filling byte codes according to bytes; otherwise, the push operation instruction is unchanged;
step 4.3, finally judging whether other JUMP destination addresses carry before the JUMP destination address of each JUMP destination address of the JUMP destination instructions obtained in step 4.1 in sequence, if so, modifying the corresponding push operation instruction according to the length of the new JUMP destination address, and complementing the JUMP destination address according to bytes; otherwise, the push operation instruction is unchanged;
and 5, inserting the confused jump address into the basic replacement byte code, inserting the inserted basic replacement byte code into the reconstructed original byte code, generating a new intelligent contract byte code, and enhancing the security of the intelligent contract.
The beneficial effects of adopting above-mentioned technical scheme to produce lie in: according to the intelligent contract security enhancement method provided by the invention, the intelligent contract byte codes with the confusion function are generated through the methods of pattern recognition, control flow diagram reconstruction and byte code replacement, so that the analysis work of a common intelligent contract reverse analysis tool is invalid, the opacity of the intelligent contract byte codes is greatly improved, and the security of contracts is increased. Meanwhile, the method only adds few extra instructions, so that the mixed intelligent contract can not cause increased Gas consumption burden to developers and users in the process of creating and calling, and the development and use cost is greatly saved. Therefore, the method provided by the invention is used as an effective method for protecting intelligent contract byte codes from reverse analysis, and can be used for protecting contract source closing property, improving demand scenes such as contract function opacity and the like.
Drawings
FIG. 1 is a schematic process diagram of an intelligent contract security enhancement method provided by an embodiment of the invention;
FIG. 2 is a flow chart of a method for enhancing security of an intelligent contract according to an embodiment of the present invention.
Detailed Description
The following describes in further detail the embodiments of the present invention with reference to the drawings and examples. The following examples are illustrative of the invention and are not intended to limit the scope of the invention.
An intelligent contract security enhancement method, as shown in figures 1 and 2, includes the steps of:
step 1, obtaining an original byte code of an intelligent contract, recovering a control flow diagram of the original byte code of the intelligent contract, marking the destination addresses of all JUMP of the JUMP/JUMP PI instructions and the push instructions thereof, the positions of the JUMP/JUMP PI instructions and the front-back position relation between the JUMP destination addresses and the JUMP instructions (the position pointed by the destination addresses is recorded as forward before the JUMP instructions, otherwise, is recorded as reverse);
in the embodiment of the invention, the acquired intelligent contract original byte codes are as follows:
606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806329e99f07146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506064565b005b5b6000548110156078576001810190506065565b00a165627a7a72305820aa50e5bcd3618fd692c07f6ec781a31c45d1b012b78656880f2eb90ea188158e0029。
the destination addresses of all JUMP instructions of the JUMP/JUMP instructions, the positions of the JUMP/JUMP instructions and the front-back position relationship between the JUMP destination addresses and the JUMP instructions in the control flow graph of the intelligent contract primitive byte codes are shown in table 1 (all are hexadecimal character strings):
TABLE 1JUMP/JUMPI instruction information
| Byte code location | Push operation instruction | Destination address | Direction |
| 3e | 60 | 44 | forward |
| 49 | 60 | 4e | forward |
| 61 | 60 | 64 | forward |
| 6e | 60 | 78 | forward |
| 77 | 60 | 65 | reverse |
Step 2, searching a position capable of inserting the replacement byte code in the original byte code of the intelligent contract and marking an address of the insertion position;
each byte code in the original byte codes of the intelligent contract corresponds to an operation instruction, and a plurality of operation codes are sequentially arranged to form an instruction sequence; in the instruction sequences corresponding to the original byte codes of the intelligent contracts, each matched { EQ-PUSH-JUMPI } instruction sequence is used as an object code to be replaced and used for confusing a byte code control flow diagram of the intelligent contracts; in this embodiment, only the address of PUSH in the first group of instruction sequences is marked as the address of the insertion position;
the inserted byte code position in this embodiment is 0x3c, i.e., the byte code position of PUSH1 in the first set of { EQ-PUSH1-JUMPI } instruction sequences that occur. The jump destination address with the byte code position of 3e in table 1 is the jump address to be confused.
Step 3, a user selects any one of four address confusion modes to replace byte codes, and different basic replacement byte codes are generated according to the selected different address confusion modes;
the four address confusion modes are respectively as follows:
address confusion pattern 1: obtaining a jump address using a memory access;
address confusion pattern 2: obtaining a jump address by using storage access;
address confusion pattern 3: obtaining a jump address by calculation using a sha3 () function;
address confusion pattern 4: obtaining a return value as a jump address using an external contract call;
when the user selects address confusion mode 1, the basic replacement byte codes are as follows: "[ x ]604052604051";
when the user selects address confusion mode 2, the basic replacement byte codes are as follows: "[ x ]604055604054";
when the user selects address confusion mode 3, its basic replacement bytecode is:
“60ff6050526001606f20600f1660099004[**][**]02”；
when the user selects address confusion pattern 4, its underlying replacement bytecode is:
“[**][**]61007d60048073bde95422681e4c3984635af2f2f35f8c44a4ddc973ffffffffffffffffffffffffffffffffffffffff1690602001909190505060008173ffffffffffffffffffffffffffffffffffffffff16638dde08406000604051602001526040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b15156102c65a03f115155050506040518051905090509190505016”；
wherein, [ x ] represents the skip address and the byte code of the push operation instruction which need to be confused;
because the replacement byte codes of all four address confusion modes are completely consistent in terms of the whole replacement method and flow of the byte codes except different instruction operations, the embodiment only selects the address confusion mode 1 for demonstration, and the basic replacement byte codes are as follows: 6044604052604051.
step 4, reconstructing all jump destination addresses and jump instructions in the basic replacement byte codes and the original byte codes, and recovering a normal control flow diagram of the intelligent contract byte codes;
step 4.1, judging the front-back relation between the destination address of each JUMP/JUMP PI instruction in step 1 and the inserting position address in step 2 in turn, if the JUMP destination address is behind the inserting position, adding the byte length of the inserting code to the JUMP destination address to obtain a new JUMP destination address; otherwise, the destination address of JUMP of the JUMP/JUMP instruction is unchanged;
in this embodiment, all jump addresses and instruction cases after the execution of step 4.1 are shown in table 2:
TABLE 2 New jump Address and instruction
| Byte code location | Push operation instruction | Destination address | Direction |
| 44 | 60 | 4a | forward |
| 4f | 60 | 54 | forward |
| 67 | 60 | 6a | forward |
| 74 | 60 | 7e | forward |
| 7d | 60 | 6b | reverse |
Step 4.2, judging whether the destination address jumped by each JUMP destination address obtained in the step 4.1 is carried or not in sequence, if so, modifying the corresponding push operation instruction according to the length of the new jumped destination address, and meanwhile, filling byte codes according to bytes; otherwise, the push operation instruction is unchanged;
in this embodiment, after step 4.1, no carry occurs in the JUMP destination address of the JUMP/JUMP instruction, so the push operation instruction is unchanged.
Step 4.3, finally judging whether other JUMP destination addresses carry before the JUMP destination address of each JUMP destination address of the JUMP destination instructions obtained in step 4.1 in sequence, if so, modifying the corresponding push operation instruction according to the length of the new JUMP destination address, and complementing the JUMP destination address according to bytes; otherwise, the push operation instruction is unchanged;
in this embodiment, after step 4.1, no other JUMP destination address carries before the JUMP destination address of each JUMP/JUMP pi instruction points to, so the push operation instruction is unchanged.
And 5, inserting the confused jump address into the basic replacement byte code, inserting the inserted basic replacement byte code into the reconstructed original byte code, generating a new intelligent contract byte code, and enhancing the security of the intelligent contract.
In this embodiment, after inserting the jump address and the push instruction after confusion, the replacing bytecode is: 604a604052604051, inserting the replacement byte code into the reconstructed original byte code, and obtaining a new intelligent contract byte code as follows:
606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806329e99f0714604a604052604051575b600080fd5b3415605457600080fd5b60626004808035906020019091905050606a565b005b5b600054811015607e57600181019050606b565b00a165627a7a72305820aa50e5bcd3618fd692c07f6ec781a31c45d1b012b78656880f2eb90ea188158e0029。
wherein the byte code 604a604052604051 of the second row is the inserted replacement byte code, the byte code 54 of the second row, the byte codes 6a, 7e of the third row, and the byte code 6b of the fourth row is the modified jump address. The intelligent contract byte code obtained by the method can ensure that the reverse tool fails in analyzing the contract byte code on the basis of ensuring normal contract functions, and plays a role in protecting the contract byte code.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and are not limiting; although the invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some or all of the technical features thereof can be replaced with equivalents; such modifications and substitutions do not depart from the spirit of the corresponding technical solutions, which are defined by the scope of the appended claims.
Claims (3)
1. An intelligent contract security enhancement method is characterized in that: the method comprises the following steps:
step 1, acquiring an original byte code of an intelligent contract, recovering a control flow diagram of the original byte code of the intelligent contract, and marking destination addresses of all JUMP instructions of the JUMP instructions, a stack-entering instruction of the JUMP instructions, positions of the JUMP instructions and front-back position relations between the JUMP destination addresses and the JUMP instructions;
step 2, searching a position capable of inserting the replacement byte code in the original byte code of the intelligent contract and marking an address of the insertion position;
step 3, a user selects any one of four address confusion modes to replace byte codes, and different basic replacement byte codes are generated according to the selected different address confusion modes;
the four address confusion modes are respectively as follows:
address confusion pattern 1: obtaining a jump address using a memory access;
address confusion pattern 2: obtaining a jump address by using storage access;
address confusion pattern 3: obtaining a jump address by calculation using a sha3 () function;
address confusion pattern 4: obtaining a return value as a jump address using an external contract call;
when the user selects address confusion mode 1, the basic replacement byte codes are as follows: "[ x ]604052604051";
when the user selects address confusion mode 2, the basic replacement byte codes are as follows: "[ x ]604055604054";
when the user selects address confusion mode 3, its basic replacement bytecode is:
“60ff6050526001606f20600f1660099004[**][**]02”；
when the user selects address confusion pattern 4, its underlying replacement bytecode is:
“[**][**]61007d60048073bde95422681e4c3984635af2f2f35f8c44a4ddc973ffffffffffffffffffffff ffffffffffffffffff1690602001909190505060008173ffffffffffffffffffffffffffffffffffffffff16638dde08406000604051602001526040518163ffffffff167c0100000000000000000000000000000000000000000000 000000000000028152600401602060405180830381600087803b15156102c65a03f115155050506040518051905090509190505016”；
wherein, [ x ] represents the skip address and the byte code of the push operation instruction which need to be confused;
step 4, reconstructing all jump destination addresses and jump instructions in the basic replacement byte codes and the original byte codes, and recovering a normal control flow diagram of the intelligent contract byte codes;
and 5, inserting the confused jump address into the basic replacement byte code, inserting the inserted basic replacement byte code into the reconstructed original byte code, generating a new intelligent contract byte code, and enhancing the security of the intelligent contract.
2. The smart contract security enhancement method of claim 1, wherein: the specific method of the step 2 is as follows:
and in the instruction sequences corresponding to the original byte codes of the intelligent contracts, each matched { EQ-PUSH-JUMPI } instruction sequence is used as an object code to be replaced, and is used for confusing the byte code control flow diagrams of the intelligent contracts.
3. The smart contract security enhancement method of claim 1, wherein: the specific method of the step 4 is as follows:
step 4.1, judging the front-back relation between the destination address of each JUMP/JUMP PI instruction in step 1 and the inserting position address in step 2 in turn, if the JUMP destination address is behind the inserting position, adding the byte length of the inserting code to the JUMP destination address to obtain a new JUMP destination address; otherwise, the destination address of JUMP of the JUMP/JUMP instruction is unchanged;
step 4.2, judging whether the destination address jumped by each JUMP destination address obtained in the step 4.1 is carried or not in sequence, if so, modifying the corresponding push operation instruction according to the length of the new jumped destination address, and meanwhile, filling byte codes according to bytes; otherwise, the push operation instruction is unchanged;
step 4.3, finally judging whether other JUMP destination addresses carry before the JUMP destination address of each JUMP destination address of the JUMP destination instructions obtained in step 4.1 in sequence, if so, modifying the corresponding push operation instruction according to the length of the new JUMP destination address, and complementing the JUMP destination address according to bytes; otherwise, the push operation instruction is unchanged.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010211696.8A CN111563237B (en) | 2020-03-24 | 2020-03-24 | Intelligent contract security enhancement method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010211696.8A CN111563237B (en) | 2020-03-24 | 2020-03-24 | Intelligent contract security enhancement method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111563237A CN111563237A (en) | 2020-08-21 |
| CN111563237B true CN111563237B (en) | 2023-08-08 |
Family
ID=72071485
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010211696.8A Active CN111563237B (en) | 2020-03-24 | 2020-03-24 | Intelligent contract security enhancement method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111563237B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112631611B (en) * | 2021-01-06 | 2022-06-03 | 中山大学 | Intelligent Pompe deception contract identification method and device |
| CN113504940B (en) * | 2021-07-28 | 2023-04-07 | 电子科技大学 | Method and device for improving reverse engineering effect of intelligent contract bytecode |
| CN114385185A (en) * | 2021-12-24 | 2022-04-22 | 深圳前海微众银行股份有限公司 | Method and device for generating control flow graph of intelligent contract |
| CN116743499B (en) * | 2023-08-09 | 2023-10-27 | 杭州安碣信息安全科技有限公司 | Imitation transaction generation method for intelligent contract attack |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101853357A (en) * | 2010-04-28 | 2010-10-06 | 北京飞天诚信科技有限公司 | Software protection method |
| CN110674533A (en) * | 2019-09-25 | 2020-01-10 | 浙江大学 | Block chain consensus excitation system and method based on large-scale scientific core calculation |
| CN110717746A (en) * | 2019-10-14 | 2020-01-21 | 杭州复杂美科技有限公司 | Transfer method, transfer system, address naming equipment and storage medium |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US11128603B2 (en) * | 2016-09-30 | 2021-09-21 | Nec Corporation | Method and system for providing a transaction forwarding service in blockchain implementations |
| SG11202003808PA (en) * | 2019-06-28 | 2020-05-28 | Advanced New Technologies Co Ltd | System and method for data processing |
-
2020
- 2020-03-24 CN CN202010211696.8A patent/CN111563237B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101853357A (en) * | 2010-04-28 | 2010-10-06 | 北京飞天诚信科技有限公司 | Software protection method |
| CN110674533A (en) * | 2019-09-25 | 2020-01-10 | 浙江大学 | Block chain consensus excitation system and method based on large-scale scientific core calculation |
| CN110717746A (en) * | 2019-10-14 | 2020-01-21 | 杭州复杂美科技有限公司 | Transfer method, transfer system, address naming equipment and storage medium |
Non-Patent Citations (1)
| Title |
|---|
| "区块链应用系统若干脆弱性分析与评测";曾晶晶;《中国优秀硕士学位论文全文数据库——信息科技辑》;20190915;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111563237A (en) | 2020-08-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111563237B (en) | Intelligent contract security enhancement method | |
| CN108614960B (en) | JavaScript virtualization protection method based on front-end byte code technology | |
| TW200841209A (en) | Obfuscating computer program code | |
| CN108733988A (en) | The guard method of executable program on Android platform | |
| Madou et al. | Software protection through dynamic code mutation | |
| US8589897B2 (en) | System and method for branch extraction obfuscation | |
| CN108681457A (en) | The Android application program guard methods explained with residual code based on code sinking | |
| Kalysch et al. | VMAttack: deobfuscating virtualization-based packed binaries | |
| CN108491235A (en) | In conjunction with the DEX guard methods of dynamic load and function Nativeization | |
| US20110167407A1 (en) | System and method for software data reference obfuscation | |
| CN104462990A (en) | Character string decrypting and encrypting method and device | |
| CN110245467A (en) | Android application program guard method based on Dex2C and LLVM | |
| CN106960140A (en) | Virtual machine instructions obscure method and device, virtual machine protection system | |
| WO2021244054A1 (en) | Contract code obfuscation platform and obfuscation method based on smart contract bytecode features | |
| CN112163195A (en) | Novel virtual machine software protection method based on stack hiding | |
| CN107203500A (en) | The automatic switching method of the excel formula object oriented languages of expansion backtracking is replaced based on recurrence | |
| CN101366035B (en) | Method for execution of application program of compiling an intermediate language software code | |
| CN111723345A (en) | Callback function-based control flow obfuscation method and system | |
| CN113626773B (en) | Code protection method based on intermediate language | |
| CN111190585B (en) | Method for realizing JAVA mode matching characteristic based on byte code enhancement technology | |
| US7958490B2 (en) | System for automating the definition of application objects supporting undoing, redoing compressing and logging operations | |
| He et al. | Tamperproofing a software watermark by encoding constants | |
| CN108733990B (en) | Block chain-based file protection method and terminal equipment | |
| CN114637988A (en) | Binary-oriented function level software randomization method | |
| CN112114809B (en) | Program code safety protection method, device and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |