CN113536310A - Code file processing method, code file checking device and electronic equipment - Google Patents
Code file processing method, code file checking device and electronic equipment Download PDFInfo
- Publication number
- CN113536310A CN113536310A CN202110773908.6A CN202110773908A CN113536310A CN 113536310 A CN113536310 A CN 113536310A CN 202110773908 A CN202110773908 A CN 202110773908A CN 113536310 A CN113536310 A CN 113536310A
- Authority
- CN
- China
- Prior art keywords
- code
- code block
- function
- blocks
- block
- 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.)
- Pending
Links
- 238000003672 processing method Methods 0.000 title abstract description 16
- 238000013507 mapping Methods 0.000 claims abstract description 159
- 238000000034 method Methods 0.000 claims abstract description 59
- 238000012795 verification Methods 0.000 claims abstract description 32
- 230000006870 function Effects 0.000 claims description 222
- 238000004590 computer program Methods 0.000 claims description 18
- 238000012545 processing Methods 0.000 claims description 18
- 238000001514 detection method Methods 0.000 description 12
- 230000008569 process Effects 0.000 description 11
- 238000010586 diagram Methods 0.000 description 6
- 230000006399 behavior Effects 0.000 description 5
- 238000005516 engineering process Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 238000005336 cracking Methods 0.000 description 1
- 230000007123 defense Effects 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 238000002513 implantation Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000011022 operating instruction Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
Images
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/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/55—Detecting local intrusion or implementing counter-measures
- G06F21/56—Computer malware detection or handling, e.g. anti-virus arrangements
- G06F21/562—Static detection
- G06F21/563—Static detection by source code analysis
Abstract
The embodiment of the specification provides a code file processing method, a code file checking device and electronic equipment. The processing method comprises the following steps: splitting function codes of at least one function in the code file into a plurality of ordered code blocks; determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block. Correspondingly, the verification method comprises the following steps: determining at least one preceding code block and a succeeding code block forming a preset mapping rule from a plurality of code blocks of a code file; and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
Description
Technical Field
The present invention relates to the field of data security technologies, and in particular, to a method and an apparatus for processing a code file, and an electronic device.
Background
In the client security attack and defense game, a hacker usually tampers with the code file to achieve the purpose of cheating, such as cracking of the registration code, implantation of plug-in, and the like. For such attack methods, the existing protection strategy usually adopts a single point check on a code file to identify the attack behavior of a hacker. And once the hacker determines the check point of the code file through a reverse technology, the detection of the protection strategy can be bypassed again through modifying the check logic.
In view of the above, it is desirable to develop a more effective code file verification scheme, which can prevent hackers from evading attack detection through a reverse technique.
Disclosure of Invention
Embodiments of the present disclosure provide a code file processing method, a code file checking device, and an electronic device, which can effectively detect that a hacker checks an attack behavior of a code file, and the hacker cannot modify a check logic by a reverse technique to avoid attack detection.
In order to achieve the above object, the embodiments of the present specification are implemented as follows:
in a first aspect, a method for processing a code file is provided, including:
splitting function codes of at least one function of the code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
In a second aspect, a method for verifying a code file is provided, including:
determining at least one prior code block and a subsequent code block which form a preset mapping rule from a plurality of ordered code blocks of a code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the prior code block are added in the subsequent code block under the preset mapping rule;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
In a third aspect, an apparatus for processing a code file is provided, including:
the code splitting module is used for splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
the mapping matching module is used for determining a prior code block and a subsequent code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and the check code adding module is used for adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks.
In a fourth aspect, an electronic device is provided comprising: a memory, a processor, and a computer program stored on the memory and executable on the processor, the computer program being executed by the processor to:
splitting function codes of at least one function in a code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
In a fifth aspect, a computer-readable storage medium is provided, having stored thereon a computer program which, when executed by a processor, performs the steps of:
splitting function codes of at least one function in a code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
In a sixth aspect, there is provided an apparatus for verifying a code file, comprising:
the mapping rule matching module is used for determining at least one preceding code block and at least one following code block which form a preset mapping rule from a plurality of ordered code blocks of the code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the preceding code blocks are added in the following code blocks under the preset mapping rule;
and the code checking module is used for checking the prior code blocks belonging to the same preset mapping rule based on the checking codes in the subsequent code blocks under the at least one preset mapping rule.
In a seventh aspect, an electronic device is provided that includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, the computer program being executed by the processor to:
determining at least one preceding code block and at least one following code block which form preset mapping rules from a plurality of code blocks of a code file, wherein the plurality of code blocks form the preceding code blocks and the following code blocks which have a plurality of groups of preset mapping rules, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
In an eighth aspect, a computer readable storage medium is provided, having a computer program stored thereon, which when executed by a processor, performs the steps of:
determining at least one preceding code block and at least one following code block which form preset mapping rules from a plurality of code blocks of a code file, wherein the plurality of code blocks form the preceding code blocks and the following code blocks which have a plurality of groups of preset mapping rules, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
In the scheme of the embodiment of the present specification, a function code of a code file is split into a plurality of ordered code blocks, and in the plurality of codes, a plurality of groups of preceding code blocks and succeeding code blocks forming a preset mapping rule are established, so that a check code for checking the preceding code blocks under each preset mapping rule is added to the corresponding succeeding code blocks. If a hacker wants to tamper with the function codes of the code file without being discovered, the hacker needs to know the preset mapping rule among the code blocks, determine on which other code block the check code of the tampered code block is stored, and tamper the check code stored in the other code block. Meanwhile, the check code stored in the other code block also has check content which can be the check code in the other code block, so that the check code is further required to be modified step by step to escape detection, and the check code is almost impossible to realize theoretically. It can thus be seen that the scheme of the present description, which is an example, has code verification capabilities that prevent hackers from escaping attack detection through reverse techniques.
Drawings
In order to more clearly illustrate the embodiments of the present specification or the technical solutions in the prior art, the drawings needed to be used in the description of the embodiments or the prior art will be briefly introduced below, it is obvious that the drawings in the following description are only some embodiments described in the embodiments of the present specification, and for those skilled in the art, other drawings can be obtained according to the drawings without any creative efforts.
Fig. 1 is a schematic flowchart of a method for processing a code file according to an embodiment of the present disclosure.
Fig. 2 is a schematic flowchart of a verification method for a code file according to an embodiment of the present disclosure.
Fig. 3 is a schematic structural diagram of a code file processing apparatus according to an embodiment of the present disclosure.
Fig. 4 is a schematic structural diagram of a verification apparatus for a code file provided in an embodiment of this specification.
Fig. 5 is a schematic structural diagram of an electronic device provided in an embodiment of this specification.
Detailed Description
In order to make those skilled in the art better understand the technical solutions in the present specification, the technical solutions in the embodiments of the present specification will be clearly and completely described below with reference to the drawings in the embodiments of the present specification, and it is obvious that the described embodiments are only a part of the embodiments of the present specification, and not all of the embodiments. All other embodiments obtained by a person skilled in the art based on the embodiments in the present specification without any inventive step should fall within the scope of protection of the present specification.
As mentioned above, existing protection strategies against hacking code files generally employ a single point of verification of the code file to identify hacking behavior of the hacker. And once the hacker determines the check point of the code file through a reverse technology, the detection of the protection strategy can be bypassed again through modifying the check logic. In view of the above, this document aims at providing a code file verification scheme that can effectively prevent hackers from escaping attack detection through a reverse technique.
Fig. 1 is a flowchart of a processing method of a code file according to an embodiment of the present specification. The method shown in fig. 1 may be performed by corresponding hardware below, comprising the steps of:
s102, splitting the function code of at least one function of the code file into a plurality of ordered code blocks.
Here, the function code splitting manner of at least one function is not specifically limited, as long as the obtained code block corresponds to a valid order bit.
Introduction by way of example:
the at least one function can be split into a plurality of code blocks according to the sequence of the function in the code file; for example, if there are three functions in the code file, namely, the sequential function A, B, C, the function A, B, C may be split into code blocks 1-10, where the code blocks 1-3 are obtained by splitting the function code of the function a, the code blocks 4-7 are obtained by splitting the function code of the function B, and the code blocks 8-10 are obtained by splitting the function code of the function C.
Alternatively, the first and second electrodes may be,
at least one function may be split into a plurality of code blocks in the order of function codes, respectively. For example, assuming that there is a function A, B, C in the code file, which is the same as the above example, the function code of function A can be split into code blocks A1-A3Splitting the function code of the function B into code blocks B1-B4Splitting the function code of the function C into code blocks C1-C3Here, the number of code blocks obtained is also 3+4+3 — 10.
S104, determining a prior code block and a subsequent code block which form a plurality of groups of preset mapping rules from the plurality of code blocks.
It should be understood that the preset mapping rule of the embodiment of the present specification can be flexibly set, and is not specifically limited herein.
As one possible implementation manner, the presetting of the mapping rule may include: every two code blocks which are separated by N bit code blocks form a mapping relation (N is a natural number which is less than the total number of the code blocks).
Assuming that there are code blocks 1-10, when N is 0, the code block 1 and the code block 2 form a preset mapping rule, and the code block 1 is used as a previous code block of the code block 2; the code block 2 and the code block 3 form a preset mapping rule, and the code block 2 is used as a previous code block of the code block 3; … … the code blocks 9 and 10 form a preset mapping rule with the code block 2 as the preceding code block of the code block 3. It should be understood that, under the preset mapping rule, if a preceding code block is a subsequent code block of other code blocks at the same time, the preceding code block is added with a check code for checking the other code blocks.
Similarly, when the value of N is 3, the code block 1 and the code block 4 form a preset mapping rule, and the code block 1 is used as a previous code block of the code block 4; the code block 2 and the code block 5 form a preset mapping rule, and the code block 2 is used as a previous code block of the code block 5; … … the code block 7 and the code block 10 form a preset mapping rule, the code block 7 being a preceding code block of the code block 10.
And S106, adding the check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
Here, this step may generate a check code for integrity checking the previous code block and then add the check code to the corresponding subsequent code block.
It should be understood that the integrity check is to check all contents in the code block, and therefore, in this embodiment of the specification, if a check code used for checking other code blocks is added to a previous code block under a preset mapping rule, a check code in a subsequent code block corresponding to the previous code block is used for checking a function code and a check code in the previous code block.
For example, the code block 2 and the code block 3 form a preset mapping rule, and the code block 3 and the code block 4 form a preset mapping rule, then the code block 3 includes two parts of code contents, that is, an original function code and a check code added subsequently for checking the code block 2, and the check code for checking the code block 3 is used for checking two parts of code contents, that is, the function code in the code block 3 and the check code for checking the code block 2. That is, based on the way of adding check codes in sequence, once the function code of a certain middle-bit code block is tampered by a hacker, the hacker also needs to continuously modify the check codes of subsequent code blocks to ensure that the check codes are not verified, which is almost impossible to implement in practical application.
Further, based on the above mechanism, there is no corresponding check code in the first code block, and for this reason, the embodiments of the present specification may add the check code of the read-only data in the code file to the first code block by using this feature. If at least one function in the code file is divided into a plurality of code blocks according to the function code sequence before, a check code for checking read-only data in the code file can be added to the first code block of one target function. It should be understood that, under the preset mapping rule, if the first code block is taken as the previous code block, the check code of the subsequent code block corresponding to the first code block is used for checking the function code and the check code in the first code block.
In addition, the check code added to the code block can be distinguished from the function code, so that the check code is conveniently identified, and convenience is provided for a scene that the check code in the code file needs to be stripped out subsequently. Here, the check code and the function code in the code block may be distinguished by a coding scheme of the check code added to the code block being different from a coding scheme of the function code in the code block, or by a scheme in which the check code added to the code block includes a check character for checking and a flag character for marking the check code.
As can be seen, the processing method in the embodiments of the present specification splits a function code of a code file into a plurality of ordered code blocks, and establishes a plurality of groups of previous code blocks and subsequent code blocks forming a preset mapping rule among the plurality of codes, so as to add a check code for checking the previous code blocks under each preset mapping rule to the corresponding subsequent code blocks. If a hacker wants to tamper with the function codes of the code file without being discovered, the hacker needs to know the preset mapping rule among the code blocks, determine on which other code block the check code of the tampered code block is stored, and tamper the check code stored in the other code block. Meanwhile, the check code stored in the other code block also has check content which can be the check code in the other code block, so that the check code is further required to be modified step by step to escape detection, and the check code is almost impossible to realize theoretically. Therefore, the code file processed by the method of the embodiment of the present specification can have the code verification capability of preventing hackers from escaping attack detection through a reverse technique.
In addition, the embodiment of the present disclosure further provides a verification method for a code file processed by the processing method. FIG. 2 is a flow chart of a processing method according to an embodiment of the present disclosure. The method shown in fig. 2 may be performed by corresponding hardware below, comprising the steps of:
s202, determining at least one prior code block and a subsequent code block which form a preset mapping rule from a plurality of ordered code blocks of the code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the prior code block are added in the subsequent code block under the preset mapping rule.
S204, based on the check code in the posterior code block under the at least one preset mapping rule, the prior code block under the same preset mapping rule is checked.
Obviously, the verification method of the embodiment of the present specification may determine, from the code file processed by the method shown in fig. 1, a previous code block and a subsequent code block having a preset mapping rule, and extract a verification code from the subsequent code block to verify the previous code block, so as to check whether the previous code block is tampered, thereby effectively identifying an attack behavior of a hacker on the code file.
Certainly, in practical application, the more the first code blocks and the later code blocks forming the preset mapping rule are determined and response detection is performed, the better the function coding tampering identification capability is correspondingly obtained. In one possible solution, all the previous code blocks and the following code blocks forming the preset mapping rule may be determined, and the previous code blocks belonging to the same preset mapping rule may be checked based on the check codes in the following code blocks under all the preset mapping rules. And when all the prior code blocks under the preset mapping rule pass the verification, determining that the function codes in the code file are successfully verified, and judging that the problem that the function codes are tampered does not exist.
In addition, referring to the foregoing, if the first code block in the code file is added with a check code for checking read-only data in the code file, the checking method according to the embodiment may further check the read-only data in the code file based on the check code of the first code block.
For convenience and understanding of the processing method and the verification method of the embodiment of the present application, the code file containing the function A, B, C is taken as an example, and the principle of the solution is described in detail in conjunction with different implementations.
Implementation mode one
The processing flow of the code file comprises the following steps:
the function A, B, C is split into ordered code blocks 1-10, wherein the code blocks 1-3 are obtained by splitting the function codes of the function A, the code blocks 4-7 are obtained by splitting the function codes of the function B, and the code blocks 8-10 are obtained by splitting the function codes of the function C.
The preset mapping rule is set to be that every two code blocks which are separated by 0 bit code blocks form a mapping relation, namely, any two adjacent code blocks can form mapping.
And then, adding a check code to the code block according to the preset mapping rule, wherein the corresponding process comprises the following steps:
traversing a target code block in sequence without repetition;
judging whether the target code block is a first code block or not;
if so, generating a check code for checking read-only data in the code file, adding the check code into the target code block, and generating a new check code for checking 'function code + check code' in the target code block, wherein the new check code is used for being added into the next code block;
if not, adding the generated check code for checking the 'function code + check code' in the last code block into the target code block; meanwhile, if the target code block is not the last-bit code block, a new check code for checking "function code + check code" in the target code block is generated, the new check code being for addition to the next-bit code block.
Then, judging whether traversing is finished or not; if yes, ending, otherwise, continuing to not repeatedly traverse a new target code block, and continuing to add the check code.
Correspondingly, the verification process of the code file comprises the following steps:
extracting the check codes added in the code blocks 1-10; and based on the check code of the code block 1, checking the read-only data in the code file, and based on other bit code blocks, checking the 'function code + check code' of the previous bit code block corresponding to the other bit code blocks.
And if the read-only data and the code blocks 1-9 pass the verification, determining that the code file is not tampered.
Implementation mode two
The function A, B, C is split into ordered code blocks 1-10, wherein the code blocks 1-3 are obtained by splitting the function codes of the function A, the code blocks 4-7 are obtained by splitting the function codes of the function B, and the code blocks 8-10 are obtained by splitting the function codes of the function C.
And setting a preset mapping rule to form a mapping relation between two code blocks every two code blocks which are separated by 2 bits.
Then, adding a check code to the code block according to the preset mapping rule, wherein the corresponding process comprises the following steps:
traversing a target code block in sequence without repetition;
judging whether the target code block is a first code block or not;
if yes, generating a check code for checking read-only data in the code file, adding the check code into the target code block, and generating a new check code for checking 'function code + check code' in the target code block, wherein the new check code is used for being added into an X +2 th uncoded block, and X represents the bit number of the current target code block;
if not, judging whether the X +2 exceeds the total number of the code blocks by 10; if X +2 does not exceed the total number of 10, adding a check code which is generated and used for checking the 'function code + check code' in the X-2 th bit code block into the target code block, and simultaneously if the target code block is not the last bit code block, generating a new check code which is used for being added into the X +2 th bit code block and used for checking the 'function code + check code' in the target code block at the moment; if X +2 exceeds the total number of 10, the process ends.
Correspondingly, the verification process of the code file comprises the following steps:
and selecting partial code blocks 2, 3 and 5 from the code blocks 1-10 as verification objects. Then, the read-only data in the code file is verified based on the check code of the code block 1, the 'function code + check code' of the code block 3 is verified based on the check code of the code block 5, the 'function code + check code' of the code block 3 is verified based on the check code of the code block 6, and the 'function code + check code' of the code block 5 is verified based on the check code of the code block 8.
It should be noted that, in the second implementation, since a mapping can be formed between a preceding code block and a succeeding code block which are two code blocks apart, there is no corresponding succeeding code block in the code blocks from the 8 th bit onward. If the code blocks 8, 9 need to be checked, a check code can be calculated for the code blocks 8, 9 as a whole and added to the last code block 10. That is, when N is greater than 1, the preset mapping relationship may further be set to include: a mapping relationship is formed between a virtual code block of an M-N bit code block to a last bit code block combination and a last bit code block, where M represents the total number of code blocks in the code file (the virtual code block does not count within M).
And after all the checks are passed, determining that the code file is not tampered.
Implementation mode three
The processing flow of the code file comprises the following steps:
respectively splitting function codes of the function A, B, C to obtain a code block A of the function A1-A3Code block B of function B1-B4Code block C of function C1-C3。
And setting a preset mapping rule to form a mapping relation between two code blocks which are separated by 0 bit code block. That is, any two adjacent code blocks in the function may form a mapping.
Then, adding a check code to the code block according to the preset mapping rule, wherein the corresponding process comprises the following steps:
traversing a target code block in sequence without repetition;
judging whether the target code block is a first code block or not;
if so, generating a check code for checking read-only data in the code file, adding the check code into the target code block, and generating a new check code for checking 'function code + check code' in the target code block, wherein the new check code is used for being added into the next code block;
if not, adding the generated check code for checking the 'function code + check code' in the previous code block into the target code block, and generating a new check code for checking the 'function code + check code' in the target code block at the moment, wherein the new check code is used for being added into the next code block;
then, judging whether traversing all code blocks of the current function is finished or not; if yes, ending, otherwise, continuing to not repeatedly traverse a new target code block.
Correspondingly, the verification process of the code file is executed by separately executing each function, taking the function a as an example, the process includes:
from each code block A in the extraction function A1-A3Based on code block A1The check code of (A) checks the read-only data in the code file based on the code block A2Check code pair code block A1Based on code block A, the 'function code + check code' is checked3Check code of (2), for code block A2The "function code + check code" of (1) is checked.
Wherein if the data and code block A are read only1-A3And if the code file passes the verification, determining that the function A of the code file is not tampered.
Implementation mode four
The processing flow of the code file comprises the following steps:
the function A, B, C is ordered, such as by the ordinal position of the function A, B, C in the code file, where function a is assumed to be the first function, function B is assumed to be the second function, and function C is assumed to be the third function.
Respectively splitting function codes of the function A, B, C to obtain a code block A of the function A1-A3Code block B of function B1-B4Code block C of function C1-C3。
Two preset mapping rules are set: the first is that under the same function, the code blocks are separated by 0 bit between the preceding code block and the following code block, i.e. any two adjacent code blocks in the function can form a mapShooting; the second type is that the first code block of the non-first function is relative to the last code block of the last function corresponding to the non-first function, and is the prior code block, namely the last code block A of the function A3A first code block B being a function B1Preceding code block of (1), and similarly, last bit code block B of function B4As first-order code blocks C of the function C1The preceding code block of (1).
And then, adding a check code to the code block according to a preset mapping rule, wherein the corresponding process comprises the following steps:
traversing a target code block in sequence without repetition;
judging whether the target code block is a first code block or not;
if the first code block is the first code block, further judging whether the target code block is the first code block of the first function;
if the target code block is the first code block of the first function, generating a check code for checking read-only data in the code file, adding the check code into the target code block, and generating a new check code for checking the 'function code + check code' in the target code block, wherein the new check code is used for being added into the next code block of the function to which the new check code belongs;
if the target code block is not the first code block of the non-first function, generating a check code for checking the last code block of the previous function, adding the check code into the target code block, and generating a new check code for checking the 'function code + check code' in the target code block, wherein the new check code is used for being added into the next code block of the function to which the new check code belongs;
further, if the target code block is not the first code block, adding a check code, which has been generated for checking the last code block of the function, to the target code block; meanwhile, if the target code block is not the last bit code block, a new check code for checking "function code + check code" in the target code block at that time is generated for addition to the next bit code block of the affiliated function.
After adding corresponding check codes to the target code blocks, judging whether traversing of all code blocks of the current function is finished; if yes, ending, otherwise, continuing to not repeatedly traverse a new target code block, and continuing to add the check code.
Correspondingly, the verification process of the code file comprises the following steps:
extracting code block A1-A3Code block B1-B4Code block C1-C3The added check code; code block A based on function A1The check code of (1) checks the read-only data in the code file, and checks the function code + check code of the previous code block corresponding to the function A based on the other code blocks in the function A.
At the same time, the code block B based on the function B1For code block A in function A3And verifying the 'function code + check code', based on other bit code blocks in the function B, the 'function code + check code' of the corresponding previous bit code block in the function B.
Further, a code block C based on the function C1For code block B in function B4And verifying the 'function code + check code', based on other bit code blocks in the function C, the 'function code + check code' of the corresponding previous bit code block in the function C.
If read-only data, code block A1-A3Code block B1-B4Code block C1-C2And if the code file passes the verification, the code file is determined to be not tampered.
The foregoing is an exemplary description of the method of embodiments of the present invention. Suitable variations may be made without departing from the principles described herein, and such variations are to be considered within the scope of the embodiments of the invention.
For example, based on the above introduction scheme, it can be seen that the last code block in the embodiment of the present description does not have a corresponding check code, and if all function codes need to be checked, when a function code is split into code blocks, a code block of an empty set is additionally introduced as the last code block (or a code block including some other information is introduced, which is not described herein by way of example), so that the check code of the last code block having actual function code content is added to the code block, thereby obtaining the checking capability.
In addition, corresponding to the processing method shown in fig. 1, an embodiment of the present invention further provides a processing apparatus for a code file. Fig. 3 is a schematic structural diagram of a consensus node 300 according to an embodiment of the present invention, including:
the code splitting module 310 is used for splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
a mapping matching module 320 for determining a preceding code block and a succeeding code block forming a plurality of sets of preset mapping rules from the plurality of code blocks;
the check code adding module 330 is configured to add a check code for checking a previous code block under each preset mapping rule to a corresponding subsequent code block.
The processing apparatus in this embodiment of the present description splits a function code of a code file into a plurality of ordered code blocks, and in the plurality of codes, sets of a preceding code block and a succeeding code block that form a preset mapping rule are established, so as to add a check code for checking the preceding code block under each preset mapping rule to the corresponding succeeding code block. If a hacker wants to tamper with the function codes of the code file without being discovered, the hacker needs to know the preset mapping rule among the code blocks, determine on which other code block the check code of the tampered code block is stored, and tamper the check code stored in the other code block. Meanwhile, the check code stored in the other code block also has check content which can be the check code in the other code block, so that the check code is further required to be modified step by step to escape detection, and the check code is almost impossible to realize theoretically. Therefore, the code file processed by the method of the embodiment of the present specification can have the code verification capability of preventing hackers from escaping attack detection through a reverse technique.
Optionally, under the preset mapping rule, if a previous code block is a subsequent code block of another code block at the same time, the previous code block is added with a check code for checking the another code block.
Optionally, under the preset mapping rule, if a check code for checking other code blocks is added to a previous code block, a check code in a subsequent code block corresponding to the previous code block is used to check the function code and the check code in the previous code block.
Optionally, the preset mapping rule includes: every two code blocks which are separated by N bit code blocks form a mapping relation, wherein N is a natural number which is less than the total number of the code blocks.
Optionally, a check code for checking read-only data in the code file is added to a first code block of the plurality of code blocks, wherein under the preset mapping rule, if the first code block is used as a previous code block, a check code of a subsequent code block corresponding to the first code block is used for checking a function code and a check code in the first code block.
Optionally, the code splitting module 310 may split the at least one function into a plurality of code blocks according to an order of the function in the code file; alternatively, the first and second electrodes may be,
the code splitting module 310 may split the at least one function into a plurality of code blocks according to a function code sequence, respectively, wherein a check code for checking read-only data in the code file is added to a first code block of a target function in the at least one function.
Optionally, the coding mode of the check code added to the code block is different from the coding mode of the function code in the code block; or, the check code added to the code block contains check characters for checking and mark characters for marking the check code.
Optionally, the at least one function is a plurality of sorted functions, and is split into a plurality of code blocks according to a function code sequence, respectively, and the preset mapping rule further includes: and the first code block of the non-first function forms a mapping relation with the last code block of the last function corresponding to the non-first function, wherein the first code block of the non-first function is used as the previous code block of the last code block of the corresponding last function.
Optionally, after the code splitting module 310 splits the function code of at least one function of the code file into a plurality of ordered code blocks, a code block of an empty set is introduced as a last bit code block in the plurality of code blocks.
Obviously, the processing device of the embodiment of the present specification can be used as the execution main body of the processing method shown in fig. 1, and thus can implement the steps and functions of the processing method implemented in fig. 1. Since the principle is the same, the detailed description is omitted here.
In addition, corresponding to the processing method shown in fig. 2, an embodiment of the present invention further provides a device for verifying a code file. Fig. 4 is a schematic structural diagram of a consensus node 400 according to an embodiment of the present invention, including:
the mapping rule matching module 410 determines at least one preceding code block and a succeeding code block forming a preset mapping rule from a plurality of ordered code blocks of the code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the preceding code block are added to the succeeding code block under the preset mapping rule;
the code checking module 420 checks the previous code blocks belonging to the same preset mapping rule based on the check codes in the previous code blocks under the at least one preset mapping rule.
Obviously, the verification apparatus of the embodiment of the present specification may determine, from the code file processed by the method shown in fig. 1, a previous code block and a subsequent code block having a preset mapping rule, and extract a verification code from the subsequent code block to verify the previous code block, so as to check whether the previous code block is tampered, thereby effectively identifying an attack behavior of a hacker on the code file.
Alternatively, the mapping matching module 420 may determine all the previous code blocks and the subsequent code blocks forming the preset mapping rule from the plurality of code blocks; correspondingly, the check code adding module 430 may check the previous code blocks belonging to the same preset mapping rule based on the check codes in the previous code blocks under all preset mapping rules. When the prior code block passes the verification under all the preset mapping rules, the code file can be determined to be successfully verified and not tampered.
Optionally, a check code for checking read-only data in the code file is added to a first code block in the plurality of code blocks. The check code adding module 430 may further check the read-only data in the code file based on the check code of the first code block in the plurality of code blocks.
Obviously, the verification apparatus in the embodiment of the present specification may be used as the execution main body of the verification method shown in fig. 2, and thus the steps and functions of the verification method implemented in fig. 2 can be implemented. Since the principle is the same, the detailed description is omitted here.
Fig. 5 is a schematic structural diagram of an electronic device according to an embodiment of the present specification. Referring to fig. 5, at a hardware level, the electronic device includes a processor, and optionally further includes an internal bus, a network interface, and a memory. The Memory may include a Memory, such as a Random-Access Memory (RAM), and may further include a non-volatile Memory, such as at least 1 disk Memory. Of course, the electronic device may also include hardware required for other services.
The processor, the network interface, and the memory may be connected to each other via an internal bus, which may be an ISA (Industry Standard Architecture) bus, a PCI (Peripheral Component Interconnect) bus, an EISA (Extended Industry Standard Architecture) bus, or the like. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one double-headed arrow is shown in FIG. 5, but this does not indicate only one bus or one type of bus.
And the memory is used for storing programs. In particular, the program may include program code comprising computer operating instructions. The memory may include both memory and non-volatile storage and provides instructions and data to the processor.
The processor reads the corresponding computer program from the nonvolatile memory into the memory and runs the computer program to form the processing device of the code file on the logic level. The processor is used for executing the program stored in the memory and is specifically used for executing the following operations:
function code of at least one function of the code file is split into an ordered plurality of code blocks.
From the plurality of code blocks, a preceding code block and a succeeding code block forming a plurality of sets of preset mapping rules are determined.
And adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
Or the processor reads the corresponding computer program from the nonvolatile memory into the memory and then runs the computer program to form the verification device of the code file on the logic level. The processor is used for executing the program stored in the memory and is specifically used for executing the following operations:
determining at least one prior code block and a subsequent code block which form a preset mapping rule from a plurality of ordered code blocks of the code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the prior code block are added in the subsequent code block under the preset mapping rule.
And checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
The processing method disclosed in the embodiment shown in fig. 1 or the verification method shown in fig. 2 may be applied to or implemented by a processor. The processor may be an integrated circuit chip having signal processing capabilities. In implementation, the steps of the above method may be performed by integrated logic circuits of hardware in a processor or instructions in the form of software. The Processor may be a general-purpose Processor, including a Central Processing Unit (CPU), a Network Processor (NP), and the like; but also Digital Signal Processors (DSPs), Application Specific Integrated Circuits (ASICs), Field Programmable Gate Arrays (FPGAs) or other Programmable logic devices, discrete Gate or transistor logic devices, discrete hardware components. The various methods, steps and logic blocks disclosed in the embodiments of the present specification may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of a method disclosed in connection with the embodiments of the present specification may be embodied directly in a hardware decoding processor, or in a combination of hardware and software modules in the decoding processor. The software module may be located in ram, flash memory, rom, prom, or eprom, registers, etc. storage media as is well known in the art. The storage medium is located in a memory, and a processor reads information in the memory and completes the steps of the method in combination with hardware of the processor.
It should be understood that the electronic device of the embodiment of the present specification can implement the functions of the embodiments of the processing method shown in fig. 1 and fig. 2. Since the principle is the same, the detailed description is omitted here.
Of course, besides the software implementation, the electronic device in this specification does not exclude other implementations, such as logic devices or a combination of software and hardware, and the like, that is, the execution subject of the following processing flow is not limited to each logic unit, and may also be hardware or logic devices.
Furthermore, the present specification embodiments also propose a computer-readable storage medium storing one or more programs, the one or more programs including instructions.
Wherein the instructions, when executed by a portable electronic device comprising a plurality of application programs, enable the portable electronic device to perform the method of the embodiment shown in fig. 1, and are specifically configured to perform the following steps:
splitting function codes of at least one function of the code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
Alternatively, the above instructions, when executed by a portable electronic device comprising a plurality of application programs, can cause the portable electronic device to perform the method of the embodiment shown in fig. 2, and specifically to perform the following steps:
determining at least one prior code block and a subsequent code block which form a preset mapping rule from a plurality of ordered code blocks of a code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the prior code block are added in the subsequent code block under the preset mapping rule;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
As will be appreciated by one skilled in the art, embodiments of the present description may be provided as a method, system, or computer program product. Accordingly, the description may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the description may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The foregoing description has been directed to specific embodiments of this disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.
The above description is only an example of the present specification, and is not intended to limit the present specification. Various modifications and alterations to this description will become apparent to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present specification should be included in the scope of the claims of the present specification. Moreover, all other embodiments obtained by a person skilled in the art without making any inventive step shall fall within the scope of protection of this document.
Claims (18)
1. A method for processing a code file, the method comprising:
splitting function codes of at least one function of the code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
2. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
and under the preset mapping rule, if the prior code block is a later code block of other code blocks at the same time, adding a check code for checking the other code blocks into the prior code block.
3. The method of claim 2, wherein the first and second light sources are selected from the group consisting of,
under the preset mapping rule, if a check code for checking other code blocks is added to a previous code block, the check code in a subsequent code block corresponding to the previous code block is used for checking the function code and the check code in the previous code block.
4. The method of claim 2, wherein the first and second light sources are selected from the group consisting of,
the preset mapping rule comprises: every two code blocks which are separated by N bit code blocks form a mapping relation, wherein N is a natural number which is less than the total number of the code blocks.
5. The method of claim 1, further comprising:
and adding a check code for checking read-only data in the code file to a first code block in the plurality of code blocks, wherein under the preset mapping rule, if the first code block is used as a previous code block, the check code of a subsequent code block corresponding to the first code block is used for checking the function code and the check code in the first code block.
6. The method of claim 4, wherein the first and second light sources are selected from the group consisting of,
splitting the function code of the at least one function into an ordered plurality of code blocks, comprising:
splitting the at least one function into a plurality of code blocks according to the sequence of the function in the code file; alternatively, the first and second electrodes may be,
and splitting the at least one function into a plurality of code blocks according to a function code sequence, wherein a check code for checking read-only data in the code file is added to a first code block of a target function in the at least one function.
7. The method of claim 6, wherein the first and second light sources are selected from the group consisting of,
the at least one function is a plurality of ordered functions, and is split into a plurality of code blocks according to the function code sequence, and the preset mapping rule further includes: and the first code block of the non-first function forms a mapping relation with the last code block of the last function corresponding to the non-first function, wherein the first code block of the non-first function is used as the previous code block of the last code block of the corresponding last function.
8. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
the coding mode of the check code added to the code block is different from the coding mode of the function code in the code block; or, the check code added to the code block contains check characters for checking and mark characters for marking the check code.
9. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
splitting function code of at least one function of a code file into an ordered plurality of code blocks, comprising:
splitting the function code of at least one function of the code file into a plurality of ordered code blocks, and introducing a code block of an empty set as a last bit code block in the plurality of code blocks.
10. A method for verifying a code file comprises the following steps:
determining at least one prior code block and a subsequent code block which form a preset mapping rule from a plurality of ordered code blocks of a code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the prior code block are added in the subsequent code block under the preset mapping rule;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
11. The method of claim 9, wherein the first and second light sources are selected from the group consisting of,
the first code block in the plurality of code blocks is added with a check code for checking read-only data in the code file, and the method further comprises the following steps:
and checking the read-only data in the code file based on the check code of the first code block in the plurality of code blocks.
12. The method of claim 9, wherein the first and second light sources are selected from the group consisting of,
determining a preceding code block and a succeeding code block forming a preset mapping rule from among the plurality of code blocks, including:
determining all prior code blocks and all subsequent code blocks forming a preset mapping rule from the plurality of code blocks;
based on the check code in the subsequent code block under the at least one preset mapping rule, checking the prior code block under the same preset mapping rule, including:
and verifying the prior code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under all preset mapping rules, wherein after all the prior code blocks forming the preset mapping rules pass the verification, the function codes in the code file are determined to be successfully verified.
13. A code file processing apparatus, comprising:
the code splitting module is used for splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
the mapping matching module is used for determining a prior code block and a subsequent code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and the check code adding module is used for adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks.
14. An electronic device includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, the computer program being executed by the processor to:
splitting function codes of at least one function in a code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
15. A computer-readable storage medium having a computer program stored thereon, which when executed by a processor, performs the steps of:
splitting function codes of at least one function in a code file into a plurality of ordered code blocks;
determining a preceding code block and a succeeding code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
and adding a check code for checking the previous code block under each preset mapping rule into the corresponding subsequent code block.
16. A verification apparatus for a code file, comprising:
the mapping rule matching module is used for determining at least one preceding code block and at least one following code block which form a preset mapping rule from a plurality of ordered code blocks of the code file, wherein the plurality of code blocks are obtained by splitting function codes of at least one function of the code file, and check codes used for checking the preceding code blocks are added in the following code blocks under the preset mapping rule;
and the code checking module is used for checking the prior code blocks belonging to the same preset mapping rule based on the checking codes in the subsequent code blocks under the at least one preset mapping rule.
17. An electronic device includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, the computer program being executed by the processor to:
determining at least one preceding code block and at least one following code block which form preset mapping rules from a plurality of code blocks of a code file, wherein the plurality of code blocks form the preceding code blocks and the following code blocks which have a plurality of groups of preset mapping rules, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
18. A computer-readable storage medium having a computer program stored thereon, which when executed by a processor, performs the steps of:
determining at least one preceding code block and at least one following code block which form preset mapping rules from a plurality of code blocks of a code file, wherein the plurality of code blocks form the preceding code blocks and the following code blocks which have a plurality of groups of preset mapping rules, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
and checking the prior code block belonging to the same preset mapping rule based on the check code in the subsequent code block under the at least one preset mapping rule.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110773908.6A CN113536310A (en) | 2021-07-08 | 2021-07-08 | Code file processing method, code file checking device and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110773908.6A CN113536310A (en) | 2021-07-08 | 2021-07-08 | Code file processing method, code file checking device and electronic equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113536310A true CN113536310A (en) | 2021-10-22 |
Family
ID=78127142
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110773908.6A Pending CN113536310A (en) | 2021-07-08 | 2021-07-08 | Code file processing method, code file checking device and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113536310A (en) |
Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20080263366A1 (en) * | 2007-04-19 | 2008-10-23 | Microsoft Corporation | Self-verifying software to prevent reverse engineering and piracy |
| WO2015101044A1 (en) * | 2013-12-30 | 2015-07-09 | 北京奇虎科技有限公司 | Method and device for feature extraction |
| CN105160253A (en) * | 2015-09-29 | 2015-12-16 | 网易（杭州）网络有限公司 | Client program restoration method, apparatus and system and server |
| CN107168872A (en) * | 2017-05-11 | 2017-09-15 | 网易（杭州）网络有限公司 | Method, device, storage medium and the processor of code check |
| CN108121911A (en) * | 2016-11-30 | 2018-06-05 | 中国移动通信有限公司研究院 | A kind of software detecting method and device |
| CN108509772A (en) * | 2018-02-12 | 2018-09-07 | 北京梆梆安全科技有限公司 | Source code reinforcement means and device based on execution sequence and single-point logic |
| CN108667553A (en) * | 2017-03-29 | 2018-10-16 | 华为技术有限公司 | Coding method, coding/decoding method, device and system |
| KR101937325B1 (en) * | 2017-10-30 | 2019-01-14 | 주식회사 시큐어링크 | Method for Detecting and Preventing Malware and Apparatus thereof |
| CN110719494A (en) * | 2019-09-06 | 2020-01-21 | 烽火通信科技股份有限公司 | Method and system for preventing CDN streaming media data from being tampered |
| WO2020134258A1 (en) * | 2018-12-27 | 2020-07-02 | 中兴通讯股份有限公司 | Data retransmission decoding method, apparatus and system, and communication device |
| CN111930555A (en) * | 2020-09-02 | 2020-11-13 | 平安国际智慧城市科技股份有限公司 | Erasure code based file processing method and device and computer equipment |
| CN113065169A (en) * | 2021-04-20 | 2021-07-02 | 支付宝(杭州)信息技术有限公司 | File storage method, device and equipment |
-
2021
- 2021-07-08 CN CN202110773908.6A patent/CN113536310A/en active Pending
Patent Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20080263366A1 (en) * | 2007-04-19 | 2008-10-23 | Microsoft Corporation | Self-verifying software to prevent reverse engineering and piracy |
| WO2015101044A1 (en) * | 2013-12-30 | 2015-07-09 | 北京奇虎科技有限公司 | Method and device for feature extraction |
| CN105160253A (en) * | 2015-09-29 | 2015-12-16 | 网易（杭州）网络有限公司 | Client program restoration method, apparatus and system and server |
| CN108121911A (en) * | 2016-11-30 | 2018-06-05 | 中国移动通信有限公司研究院 | A kind of software detecting method and device |
| CN108667553A (en) * | 2017-03-29 | 2018-10-16 | 华为技术有限公司 | Coding method, coding/decoding method, device and system |
| CN107168872A (en) * | 2017-05-11 | 2017-09-15 | 网易（杭州）网络有限公司 | Method, device, storage medium and the processor of code check |
| KR101937325B1 (en) * | 2017-10-30 | 2019-01-14 | 주식회사 시큐어링크 | Method for Detecting and Preventing Malware and Apparatus thereof |
| CN108509772A (en) * | 2018-02-12 | 2018-09-07 | 北京梆梆安全科技有限公司 | Source code reinforcement means and device based on execution sequence and single-point logic |
| WO2020134258A1 (en) * | 2018-12-27 | 2020-07-02 | 中兴通讯股份有限公司 | Data retransmission decoding method, apparatus and system, and communication device |
| CN110719494A (en) * | 2019-09-06 | 2020-01-21 | 烽火通信科技股份有限公司 | Method and system for preventing CDN streaming media data from being tampered |
| CN111930555A (en) * | 2020-09-02 | 2020-11-13 | 平安国际智慧城市科技股份有限公司 | Erasure code based file processing method and device and computer equipment |
| CN113065169A (en) * | 2021-04-20 | 2021-07-02 | 支付宝(杭州)信息技术有限公司 | File storage method, device and equipment |
Non-Patent Citations (1)
| Title |
|---|
| 李建鹏: "面向软件语言的漏洞分析技术应用研究", 中国优秀硕士学位论文全文数据库 (信息科技辑), 31 May 2021 (2021-05-31), pages 138 - 280 * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108334753B (en) | Pirate application verification method and distributed server node | |
| JP2020511059A (en) | Information authentication method and system | |
| CN110391914B (en) | File acquisition method and equipment based on two-dimensional code and two-dimensional code generation method | |
| CN111010284B (en) | Processing method of block to be identified, related device and block chain system | |
| CN110489466B (en) | Method and device for generating invitation code, terminal equipment and storage medium | |
| CN113065169A (en) | File storage method, device and equipment | |
| CN106547648A (en) | Backup data processing method and device | |
| CN111583498A (en) | Electronic voting method, system, equipment and storage medium based on block chain | |
| CN114329622A (en) | File protection method, verification method, device, equipment and medium | |
| CN107623696B (en) | User identity verification method and device based on user behavior characteristics | |
| CN113536310A (en) | Code file processing method, code file checking device and electronic equipment | |
| CN110618859B (en) | Transaction pool design method supporting sequential packaging and electronic equipment | |
| CN110737633A (en) | resource management method and system based on cloud management platform | |
| CN116305322A (en) | Program signature verification method and device, storage medium and electronic equipment | |
| CN112711570A (en) | Log information processing method and device, electronic equipment and storage medium | |
| CN111897833A (en) | Data processing method and device | |
| CN114422209B (en) | Data processing method, device and storage medium | |
| CN112149068A (en) | Access-based authorization verification method, information generation method and device, and server | |
| CN113687976B (en) | Coding and decoding method and device for DNA information storage | |
| CN109413450A (en) | A kind of integrity checking method, device, terminal and the storage medium of barrage data | |
| CN110943839A (en) | Signature verification method and device, electronic equipment and readable storage medium | |
| CN111881047B (en) | Method and device for processing obfuscated script | |
| CN112738006B (en) | Identification method, equipment and storage medium | |
| CN113553626A (en) | Data integrity detection method, device, equipment and storage medium | |
| CN111415288A (en) | Digital watermark embedding and detecting method and device |
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 |