CN113536310B - 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
- CN113536310B CN113536310B CN202110773908.6A CN202110773908A CN113536310B CN 113536310 B CN113536310 B CN 113536310B CN 202110773908 A CN202110773908 A CN 202110773908A CN 113536310 B CN113536310 B CN 113536310B
- Authority
- CN
- China
- Prior art keywords
- code
- code block
- blocks
- block
- function
- 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
- 238000003672 processing method Methods 0.000 title abstract description 16
- 238000013507 mapping Methods 0.000 claims abstract description 179
- 238000000034 method Methods 0.000 claims abstract description 50
- 238000012795 verification Methods 0.000 claims abstract description 43
- 230000006870 function Effects 0.000 claims description 229
- 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 7
- 230000006399 behavior Effects 0.000 description 5
- 238000010586 diagram Methods 0.000 description 5
- 238000012986 modification Methods 0.000 description 4
- 230000004048 modification Effects 0.000 description 4
- 230000002093 peripheral effect Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000005336 cracking Methods 0.000 description 1
- 230000007123 defense 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
- 230000004044 response Effects 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/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
Landscapes
- Engineering & Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Computer Hardware Design (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Health & Medical Sciences (AREA)
- General Health & Medical Sciences (AREA)
- Virology (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Storage Device Security (AREA)
Abstract
The embodiment of the specification provides a processing method, a checking method, a device and electronic equipment for code files. The processing method comprises the following steps: splitting function codes of at least one function in the code file into a plurality of orderly code blocks; determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; and adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks. Correspondingly, the verification method comprises the following steps: determining at least one preceding code block and a following code block forming a preset mapping rule from a plurality of code blocks of a code file; and checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
Description
Technical Field
The document belongs to the technical field of data security, and particularly relates to a code file processing method, a code file checking device and electronic equipment.
Background
In client security attack and defense games, a hacker typically tampers with the code file to achieve the purpose of cheating, such as registration code cracking, plug-in embedding, etc. For such attack modes, the existing protection strategy usually adopts single-point verification on the code file to identify the attack behavior of a hacker. And once the hacker determines the check point of the code file through the inverse technique, the detection of the protection policy can be bypassed again by modifying the check logic.
In view of this, there is a need to develop a more efficient code file verification scheme that can prevent hackers from escaping attack detection by reverse technology.
Disclosure of Invention
An embodiment of the present disclosure is directed to a method, an apparatus, and an electronic device for processing a code file, which can effectively detect that a hacker checks an attack behavior of the code file, and the hacker cannot modify a check logic by a reverse technology 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 a function code of at least one function of the code file into a plurality of ordered code blocks;
determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
And adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks.
In a second aspect, a method for verifying a code file is provided, including:
Determining at least one preceding code block and a following 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block;
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
In a third aspect, there is provided a processing apparatus for a code file, including:
The code splitting module splits 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 preceding code block and a following 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, there is provided an electronic device 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:
splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
And adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks.
In a fifth aspect, there is provided a computer readable storage medium having stored thereon a computer program which when executed by a processor performs the steps of:
splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
And adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks.
In a sixth aspect, there is provided a code file verification apparatus comprising:
the mapping rule matching module is used for determining at least one preceding code block and a 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block;
And the code verification module is used for verifying the preceding code blocks under the same preset mapping rule based on the verification codes in the following code blocks under the at least one preset mapping rule.
In a seventh aspect, there is provided an electronic device 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:
Determining at least one preceding code block and a following code block forming a preset mapping rule from a plurality of code blocks of a code file, wherein the plurality of code blocks form a plurality of groups of preceding code blocks and following code blocks of the preset mapping rule, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
In an eighth aspect, there is provided a computer readable storage medium having stored thereon a computer program which when executed by a processor performs the steps of:
Determining at least one preceding code block and a following code block forming a preset mapping rule from a plurality of code blocks of a code file, wherein the plurality of code blocks form a plurality of groups of preceding code blocks and following code blocks of the preset mapping rule, and the following code blocks under each preset mapping rule are added with check codes for checking the preceding code blocks;
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
The scheme of the embodiment of the specification splits the function code of the code file into a plurality of orderly code blocks, and establishes a plurality of groups of preceding code blocks and following code blocks forming preset mapping rules in the plurality of codes so as to add check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks. If a hacker wants to tamper with the function code of the code file without being found, he needs to know the preset mapping rule between the code blocks, determine on which other code block the verification code of the tampered code block is stored, and tamper with the verification code stored in the other code block. Meanwhile, the check code stored in the other code block can be the check content of the check code in the other code block, so that the check code is further required to be continuously modified progressively to avoid detection, which is almost impossible to realize in theory. It follows that the solution of the present description as an example has code verification capability that prevents hackers from evading attack detection by reverse technology.
Drawings
In order to more clearly illustrate the embodiments of the present description or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described below, it being obvious that the drawings in the following description are only some of the embodiments described in the embodiments of the present description, and that other drawings may be obtained according to these drawings without inventive effort to a person skilled in the art.
Fig. 1 is a flow chart illustrating a method for processing a code file according to an embodiment of the present disclosure.
Fig. 2 is a flow chart of a method for verifying a code file according to an embodiment of the present disclosure.
Fig. 3 is a schematic structural diagram of a processing device for a code file according to an embodiment of the present disclosure.
Fig. 4 is a schematic structural diagram of a verification device for a code file according to an embodiment of the present disclosure.
Fig. 5 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.
Detailed Description
In order to make the technical solutions in the present specification better understood by those skilled in the art, 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 some embodiments of the present specification, not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are intended to be within the scope of the present disclosure.
As mentioned above, existing protection strategies against hacking code files typically employ a single point verification of the code file to identify the hacking behavior of the hacker. And once the hacker determines the check point of the code file through the inverse technique, the detection of the protection policy can be bypassed again by modifying the check logic. In view of this, this document aims at providing a code file verification scheme capable of effectively preventing hackers from evading attack detection by reverse technology.
Fig. 1 is a flowchart of a processing method of a code file of the embodiment of the present specification. The method shown in fig. 1 may be performed by the following corresponding hardware, comprising the steps of:
s102, splitting function codes 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 herein, as long as the obtained code block corresponds to a valid sequence bit.
Introduction by way of example:
At least one function may be split into a plurality of code blocks in the order of the function in the code file; for example, if there are three functions in the code file, i.e., sequential function A, B, C, then function A, B, C may be split into code blocks 1-10, where code blocks 1-3 are split from the function code of function A, code blocks 4-7 are split from the function code of function B, and code blocks 8-10 are split from the function code of function C.
Or alternatively
At least one function may also be split into a plurality of code blocks in function code order, respectively. For example, assuming that the same function A, B, C as the above example exists in the code file, the function code of the function a may be split into code blocks a 1-A3, the function code of the function B into code blocks B 1-B4, and the function code of the function C into code blocks C 1-C3, where the code blocks are obtained as 3+4+3=10.
S104, determining a previous code block and a subsequent code block which form a plurality of groups of preset mapping rules from a plurality of code blocks.
It should be understood that the preset mapping rules in the embodiments of the present disclosure may be flexibly set, which is not specifically limited herein.
As one possible implementation, the preset mapping rule may include: two code blocks each separated by N bit code blocks are formed with a mapping relationship (N is a natural number less than the total number of code blocks).
Assuming that there are code blocks 1-10, when the value of 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 the prior 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 prior code block of the code block 3; … … code block 9 and code block 10 form a preset mapping rule, code block 2 being the preceding code block of code block 3. It should be understood that, under the preset mapping rule, if the preceding code block is a subsequent code block of the other code block at the same time, the preceding code block is added with a check code for checking the other code block.
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 the prior 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 prior code block of the code block 5; … … code block 7 and code block 10 form a preset mapping rule, code block 7 being the preceding code block of code block 10.
S106, adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks.
Here, the present step may generate a check code for integrity checking the preceding code block, and then add the check code to the corresponding following code block.
It should be understood that the integrity check is to check all contents in the code blocks, so in the embodiment of the present disclosure, if, under a preset mapping rule, a check code for checking other code blocks is added to a preceding code block, the check code in a subsequent code block corresponding to the preceding code block is used to check the function code and the check code in the preceding 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, so that the code block 3 includes two code contents, namely an original function code and a check code for checking the code block 2, which is added subsequently, and a check code for checking the code block 3, which is used for checking the function code in the code block 3 and the check code for checking the code block 2. That is, based on this way of adding check codes in sequence, once the function code of a certain intermediate bit code block is tampered by a hacker, the hacker needs to continuously modify the check codes of subsequent code blocks to ensure that the check codes are not checked out, which is almost impossible to realize in practical application.
Further, based on the above mechanism, the first code block has no corresponding check code, and for this reason, the embodiment of the present specification may use this feature to add the check code of the read-only data in the code file to the first code block. If at least one function in the code file is split into a plurality of code blocks according to the function code sequence, 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 used as the preceding code block, the check code of the following code block corresponding to the first code block is used to check 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 can be conveniently identified, and convenience is provided for the scene that the check code in the code file needs to be stripped out later. Here, the check code and the function code in the code block may be distinguished by the way in which the check code added to the code block is encoded differently from the function code in the code block, or by the way in which the check code added to the code block contains a check character for checking and a mark character for marking the check code.
It can be seen that the processing method in the embodiment of the present disclosure splits the function code of the code file into a plurality of ordered code blocks, and establishes a plurality of groups of preceding code blocks and following code blocks forming a preset mapping rule among the plurality of code blocks, so as to add a check code for checking the preceding code block under each preset mapping rule to the corresponding following code block. If a hacker wants to tamper with the function code of the code file without being found, he needs to know the preset mapping rule between the code blocks, determine on which other code block the verification code of the tampered code block is stored, and tamper with the verification code stored in the other code block. Meanwhile, the check code stored in the other code block can be the check content of the check code in the other code block, so that the check code is further required to be continuously modified progressively to avoid detection, which is almost impossible to realize in theory. It can be seen that the code file processed by the method according to the embodiment of the present disclosure can have a code verification capability for preventing a hacker from escaping attack detection by a reverse technique.
In addition, the embodiment of the present disclosure further provides a method for verifying the code file processed by the above processing method. Fig. 2 is a flowchart of a processing method of the embodiment of the present specification. The method shown in fig. 2 may be performed by the following corresponding hardware, comprising the steps of:
s202, determining at least one preceding code block and a following 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block.
S204, based on the check codes in the following code blocks under the at least one preset mapping rule, checking the preceding code blocks under the same preset mapping rule.
Obviously, the verification method of the embodiment of the present disclosure may determine a preceding code block and a following code block with a preset mapping rule from the code file processed by the method shown in fig. 1, and extract a verification code from the following code block to verify the preceding code block, so as to check whether the preceding code block is tampered, thereby effectively identifying an attack behavior of a hacker on the code file.
Of course, in practical application, the more preceding code blocks and the following code blocks forming the preset mapping rule are determined and response detection is performed, and the better function coding tampering identification capability is correspondingly provided. In one possible scheme, all preceding code blocks and following code blocks forming the preset mapping rule may be determined, and the preceding code blocks belonging to the same preset mapping rule are checked based on check codes in the following code blocks under all preset mapping rules. And when all the previous 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 the read-only data in the code file, the checking method of the embodiment of the present disclosure 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 according to the embodiments of the present application, the code file includes the function A, B, C as an example, and the principles of the scheme are described in detail in connection with different implementation manners.
Implementation 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 code blocks 1-3 are split from the function code of function A, code blocks 4-7 are split from the function code of function B, and code blocks 8-10 are split from the function code of function C.
The preset mapping rule is set so that a mapping relation is formed between two code blocks which are separated by 0 bit code blocks, namely, any two adjacent code blocks can form mapping.
And then, adding check codes to the code blocks according to the preset mapping rules, wherein the corresponding flow comprises the following steps:
traversing an object 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 the next code block;
If not, adding the generated check code for checking the function code and the 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 is generated that checks the "function code+check code" in the target code block, the new check code being for addition to the next bit code block.
Then, judging whether traversing is completed 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 each code block 1-10; based on the check code of the code block 1, the read-only data in the code file is checked, and based on other bit code blocks, the function code and the check code of the last bit code block corresponding to the other bit code blocks are checked.
If the read-only data and the code blocks 1-9 pass the verification, the code file is determined not to be tampered.
Implementation II
The function A, B, C is split into ordered code blocks 1-10, wherein code blocks 1-3 are split from the function code of function A, code blocks 4-7 are split from the function code of function B, and code blocks 8-10 are split from the function code of function C.
The preset mapping rule is set to form a mapping relation for two code blocks which are separated by 2bit code blocks.
And then, adding a check code to the code block according to the preset mapping rule, wherein the corresponding flow comprises the following steps:
traversing an object 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+2th uncoded block, and X represents the number of bits of the current target code block;
If not, judging whether X+2 exceeds the total number of the code blocks by 10; if X+2 does not exceed the total number 10, adding the generated check code for checking the "function code+check code" in the X-2 bit code block to the target code block, and also generating a new check code for checking the "function code+check code" in the target code block at this time if the target code block is not the last bit code block, the new check code being for addition to the X+2 bit code block; if X+2 exceeds the total number of 10, the flow 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 embodiment, since a mapping may be formed between a preceding code block and a following code block separated by two code blocks, there is no corresponding following code block in the code blocks from the 8 th bit. If the code blocks 8, 9 need to be checked, the code blocks 8, 9 can be regarded as a whole to calculate a check code and the check code is added to the last bit code block 10. That is, when N is greater than 1, the preset mapping relationship may be further set to include: the virtual code blocks of the combination of the M-N bit code blocks to the penultimate bit code blocks form a mapping relation with the last bit code block, wherein M represents the total number of code blocks in the code file (the virtual code blocks do not count into M).
After all the checks pass, it is determined that the code file has not been tampered with.
Implementation III
The processing flow of the code file comprises the following steps:
The function A, B, C is split into function codes, so that a code block A 1-A3 of the function A, a code block B 1-B4 of the function B and a code block C 1-C3 of the function C are obtained.
The preset mapping rule is set to form a mapping relation for two code blocks which are separated by 0 bit code blocks. That is, any two adjacent code blocks in the function can form a map.
And then, adding a check code to the code block according to the preset mapping rule, wherein the corresponding flow comprises the following steps:
traversing an object 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 the next code block;
if not, adding the generated check code for checking the function code and the check code in the last bit code block into the target code block, and generating a new check code for checking the function code and the check code in the target code block, wherein the new check code is used for being added into the next bit code block;
Then judging whether all code blocks of the current function are traversed; if yes, ending, otherwise, continuing to do not repeatedly traverse a new target code block.
Correspondingly, the verification process of the code file is implemented separately by each function, taking function a as an example, the process includes:
Read-only data in the code file is verified based on the check code of the code block a 1 from the check codes of the code blocks a 1-A3 in the function a, the "function code+check code" of the code block a 1 is verified based on the check code of the code block a 2, and the "function code+check code" of the code block a 2 is verified based on the check code of the code block a 3.
If both the read-only data and the code block a 1-A3 pass the verification, it is determined that the function a of the code file is not tampered.
Implementation IV
The processing flow of the code file comprises the following steps:
The functions A, B, C are ordered, such as by the order of the function A, B, C in the code file, assuming that function A is the first function, function B is the second function, and function C is the third function.
The function A, B, C is split into function codes, so that a code block A 1-A3 of the function A, a code block B 1-B4 of the function B and a code block C 1-C3 of the function C are obtained.
Two preset mapping rules are set: the first is that under the same function, a preceding code block and a following code block are separated by 0 bit code block, namely, any two adjacent code blocks in the function can form a mapping; the second type of the first code block of the non-first function is a preceding code block with respect to the last code block of the last function corresponding to the non-first function, that is, the last code block a 3 of the function a is a preceding code block of the first code block B 1 of the function B, and similarly, the last code block B 4 of the function B is a preceding code block of the first code block C 1 of the function C.
Then, adding check codes to the code blocks according to a preset mapping rule, wherein the corresponding flow comprises the following steps:
traversing an object 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 'function code plus 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;
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 last function, adding the check code to the target code block, and generating a new check code for checking the 'function code plus check code' in the target code block, wherein the new check code is used for being added to the next code block of the function;
Furthermore, if the target code block is not the first code block, adding a generated check code for checking the last code block of the function to the target code block; meanwhile, if the target code block is not the last code block, a new check code is generated to check the "function code+check code" in this time target code block, the new check code being used to be added to the next code block of the function to which it belongs.
After adding the corresponding check code to the target code block, judging whether traversing all code blocks of the current function is completed; 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 a code block A 1-A3, a code block B 1-B4 and a check code added by a code block C 1-C3; based on the check code of the code block A 1 of the function A, the read-only data in the code file is checked, and based on other bit code blocks in the function A, the function code + check code of the corresponding last bit code block in the function A is checked.
Meanwhile, based on the code block B 1 of the function B, the "function code+check code" of the code block a 3 in the function a is checked, and based on the other bit code blocks in the function B, the "function code+check code" of the corresponding last bit code block in the function B is checked.
In addition, the "function code+check code" of the code block B 4 in the function B is checked based on the code block C 1 of the function C, and the "function code+check code" of the corresponding last code block in the function C is checked based on the other bit code blocks in the function C.
If the read-only data, the code block a 1-A3, and the code block B 1-B4, and the code block C 1-C2 pass the verification, it is determined that the code file is not tampered.
The above description of the method of embodiments of the present invention is illustrative. Appropriate modifications may be made without departing from the principles herein above described and such modifications should also be considered as within the scope of embodiments of the invention.
For example, as can be seen from the above description scheme, the last code block in the embodiment of the present disclosure has no corresponding check code, if checking is needed for all function codes, an empty code block may be additionally introduced as the last code block when the function codes are split into code blocks (or a code block containing some other information may be introduced, which is not described herein in detail), so that the check code of the last code block with the 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, the embodiment of the invention further provides a processing device of the code file. Fig. 3 is a schematic structural diagram of a consensus node 300 according to an embodiment of the present invention, including:
a code splitting module 310 that splits a function code of at least one function in a code file into a plurality of code blocks in order;
a mapping matching module 320, configured to determine a preceding code block and a following code block that form a plurality of sets of preset mapping rules from the plurality of code blocks;
The check code adding module 330 adds a check code for checking the preceding code block under each preset mapping rule to the corresponding following code block.
The processing device in the embodiment of the present disclosure splits the function code of the code file into a plurality of ordered code blocks, and establishes a plurality of groups of preceding code blocks and following code blocks forming a preset mapping rule among the plurality of codes, so as to add a check code for checking the preceding code blocks under each preset mapping rule to the corresponding following code blocks. If a hacker wants to tamper with the function code of the code file without being found, he needs to know the preset mapping rule between the code blocks, determine on which other code block the verification code of the tampered code block is stored, and tamper with the verification code stored in the other code block. Meanwhile, the check code stored in the other code block can be the check content of the check code in the other code block, so that the check code is further required to be continuously modified progressively to avoid detection, which is almost impossible to realize in theory. It can be seen that the code file processed by the method according to the embodiment of the present disclosure can have a code verification capability for preventing a hacker from escaping attack detection by a reverse technique.
Optionally, under the preset mapping rule, if the preceding code block is a subsequent code block of the other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block.
Optionally, under the preset mapping rule, if a check code for checking other code blocks is added to the preceding code block, the check code in the following code block corresponding to the preceding code block is used for checking the function code and the check code in the preceding code block.
Optionally, the preset mapping rule includes: two code blocks each separated by N bit code blocks form a mapping relationship, where N is a natural number less than the total number of code blocks.
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, where under the preset mapping rule, if the first code block is used as a preceding code block, the check code of a subsequent code block corresponding to the first code block is used to check the function code and the check code in the first code block.
Alternatively, the code splitting module 310 may split the at least one function into a plurality of code blocks according to the order of the functions in the code file; or alternatively
The code splitting module 310 may split the at least one function into a plurality of code blocks according to a function code sequence, where a check code for checking read-only data in the code file is added to a first code block of an objective function in the at least one function.
Optionally, the encoding mode of the check code added to the code block is different from the encoding mode of the function code in the code block; or the check code added to the code block contains check characters for checking and marking characters for marking the check code.
Optionally, the at least one function is a plurality of ordered functions, and is split into a plurality of code blocks according to a function code sequence, and the preset mapping rule further includes: the first code block of the non-first function and the last code block of the last function corresponding to the non-first function form a mapping relation, wherein the first code block of the non-first function is used as the previous code block of the last code block shape 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 an ordered plurality of code blocks, an empty set of code blocks is introduced as the last code block in the plurality of code blocks.
It is apparent that the processing apparatus according to the embodiment of the present disclosure may be used as an execution subject of the processing method shown in fig. 1, and thus can implement the steps and functions implemented in fig. 1 by the processing method. Since the principle is the same, the description is not repeated here.
In addition, corresponding to the processing method shown in fig. 2, the embodiment of the invention also provides a device for verifying the 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 following 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block;
The code verification module 420 verifies the preceding code blocks belonging to the same preset mapping rule based on the verification code in the following code block under the at least one preset mapping rule.
Obviously, the verification device of the embodiment of the present disclosure may determine a preceding code block and a following code block having a preset mapping rule from the code file processed by the method shown in fig. 1, and extract a verification code from the following code block to verify the preceding code block, so as to check whether the preceding 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 preceding code blocks and following code blocks forming a preset mapping rule from the plurality of code blocks; correspondingly, the check code adding module 430 may check the preceding code blocks under the same preset mapping rule based on the check codes in the following code blocks under all the preset mapping rules. When all the previous code blocks pass the verification under the preset mapping rule, the code file can be determined to be successfully verified and not tampered.
Optionally, a first code block of the plurality of code blocks is added with a check code for checking read-only data in the code file. The check code adding module 430 may further perform a check on the read-only data in the code file based on the check codes of the first code blocks of the plurality of code blocks.
It is obvious that the verification device according to the embodiment of the present disclosure may be used as an execution subject of the verification method shown in fig. 2, so that the steps and functions of the verification method implemented in fig. 2 can be implemented. Since the principle is the same, the description is not repeated here.
Fig. 5 is a schematic structural view of an electronic device according to an embodiment of the present specification. Referring to fig. 5, at the hardware level, the electronic device includes a processor, and optionally 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 (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, network interface, and memory may be interconnected by an internal bus, which may be an ISA (Industry Standard Architecture ) bus, a PCI (PERIPHERAL COMPONENT INTERCONNECT, peripheral component interconnect standard) bus, or EISA (Extended Industry Standard Architecture ) bus, among others. The buses may be classified as address buses, data buses, control buses, etc. For ease of illustration, only one bi-directional arrow is shown in FIG. 5, but not only one bus or type of bus.
And the memory is used for storing programs. In particular, the program may include program code including computer-operating instructions. The memory may include memory and non-volatile storage and provide instructions and data to the processor.
The processor reads the corresponding computer program from the nonvolatile memory to the memory and then runs the computer program to form the processing device of the code file on the logic level. The processor is used for executing the programs stored in the memory and is specifically used for executing the following operations:
the function code of at least one function of the code file is split into a plurality of code blocks in order.
And determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks.
And adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks.
Or the processor reads the corresponding computer program from the nonvolatile memory to the memory and then runs the computer program to form a checking device of the code file on a logic level. The processor is used for executing the programs stored in the memory and is specifically used for executing the following operations:
And determining at least one preceding code block and a 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block.
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
The processing method disclosed in the embodiment shown in fig. 1 of the present specification or the verification method shown in fig. 2 may be applied to a processor 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 by instructions in the form of software. The processor may be a general-purpose processor, including a central processing unit (Central Processing Unit, CPU), a network processor (Network Processor, NP), etc.; but may also be a digital signal Processor (DIGITAL SIGNAL Processor, DSP), application SPECIFIC INTEGRATED Circuit (ASIC), field-Programmable gate array (Field-Programmable GATE ARRAY, FPGA) or other Programmable logic device, discrete gate or transistor logic device, discrete hardware components. The various methods, steps and logic blocks disclosed in the embodiments of this 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 hardware, in a decoded processor, or in a combination of hardware and software modules in a decoded processor. The software modules may be located in a random access memory, flash memory, read only memory, programmable read only memory, or electrically erasable programmable memory, registers, etc. as well known in the art. The storage medium is located in a memory, and the processor reads the information in the memory and, in combination with its hardware, performs the steps of the above method.
It should be understood that the electronic device of the embodiments of the present disclosure may implement the functions of the embodiments of the processing methods shown in fig. 1 and 2. Since the principle is the same, the description is not repeated here.
Of course, in addition to the software implementation, the electronic device in this specification does not exclude other implementations, such as a logic device or a combination of software and hardware, that is, the execution subject of the following process is not limited to each logic unit, but may also be hardware or a logic device.
Furthermore, the present specification embodiment also proposes a computer-readable storage medium storing one or more programs including instructions.
Wherein the instructions, when executed by a portable electronic device comprising a plurality of applications, enable the portable electronic device to perform the method of the embodiment shown in fig. 1, and in particular to perform the steps of:
splitting a function code of at least one function of the code file into a plurality of ordered code blocks;
determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks;
And adding check codes for checking the preceding code blocks under each preset mapping rule into the corresponding following code blocks.
Or instructions that, when executed by a portable electronic device comprising a plurality of applications, cause the portable electronic device to perform the method of the embodiment shown in fig. 2, and in particular to perform the steps of:
Determining at least one preceding code block and a following 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 the following code block under the preset mapping rule is added with a check code for checking the preceding code block;
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under the at least one preset mapping rule.
It will be appreciated by those skilled in the art that embodiments of the present description may be provided as a method, system, or computer program product. Accordingly, the present specification may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present description can take the form of a computer program product on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.
The foregoing describes specific embodiments of the present disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can 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 are also possible or may be advantageous.
The foregoing is merely an example of the present specification and is not intended to limit the present specification. Various modifications and alterations to this specification will become apparent to those skilled in the art. Any modifications, equivalent substitutions, improvements, or the like, which are within the spirit and principles of the present description, are intended to be included within the scope of the claims of the present description. Moreover, all other embodiments obtained by those skilled in the art without making any inventive effort shall fall within the scope of protection of this document.
Claims (15)
1. A method of processing a code file, the method comprising:
splitting a function code of at least one function of the code file into a plurality of ordered code blocks;
Determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; the preset mapping rule includes: two code blocks separated by N bit code blocks each form a mapping relation between a previous code block and a subsequent code block, wherein N is a natural number smaller than the total number of the code blocks;
Adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
2. The method of claim 1, further comprising:
And adding a check code for checking read-only data in the code file to the 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 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.
3. The method according to claim 1,
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 order of the functions in the code file; or alternatively
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 an objective function in the at least one function.
4. A method according to claim 3,
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 comprises: the first code block of the non-first function and the last code block of the last function corresponding to the non-first function form a mapping relation, wherein the first code block of the non-first function is used as the previous code block of the last code block shape of the corresponding last function.
5. The method according to claim 1,
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 marking characters for marking the check code.
6. The method according to claim 1,
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 an empty set of code blocks as last code blocks in the plurality of code blocks.
7. A method of verifying a code file, comprising:
Determining at least one preceding code block and a following code block forming 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 the preset mapping rule comprises: two code blocks which are separated by N bit code blocks each form a mapping relation between a preceding code block and a following code block, and a check code for checking the preceding code block is added to the following code block under a preset mapping rule, wherein N is a natural number smaller than the total number of the code blocks;
based on the check codes in the following code blocks under the at least one preset mapping rule, checking the preceding code blocks under the same preset mapping rule; under the preset mapping rule, if a check code for checking other code blocks is added to a preceding code block, the check code in a following code block corresponding to the preceding code block is used for checking the function code and the check code in the preceding code block; if the preceding code block is a subsequent code block to the other code block at the same time, the preceding code block is added with a check code for checking the other code block.
8. The method according to claim 7,
The first code block of 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:
And verifying the read-only data in the code file based on the verification codes of the first code blocks in the plurality of code blocks.
9. The method according to claim 7,
Determining a preceding code block and a following code block forming a preset mapping rule from the plurality of code blocks, including:
Determining all preceding code blocks and following code blocks forming a preset mapping rule from the plurality of code blocks;
Based on the check code in the following code block under the at least one preset mapping rule, checking the preceding code block under the same preset mapping rule, including:
And checking the previous code blocks belonging to the same preset mapping rule based on the check codes in the subsequent code blocks under all the preset mapping rules, wherein after all the previous code blocks forming the preset mapping rules pass the check, the success of the check of the function codes in the code file is determined.
10. A code file processing apparatus comprising:
The code splitting module splits 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 preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; the preset mapping rule includes: two code blocks separated by N bit code blocks each form a mapping relation between a previous code block and a subsequent code block, wherein N is a natural number smaller than the total number of the code blocks;
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; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
11. 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:
splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
Determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; the preset mapping rule includes: two code blocks separated by N bit code blocks each form a mapping relation between a previous code block and a subsequent code block, wherein N is a natural number smaller than the total number of the code blocks;
Adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
12. A computer readable storage medium having stored thereon a computer program which when executed by a processor performs the steps of:
splitting the function code of at least one function in the code file into a plurality of ordered code blocks;
Determining a preceding code block and a following code block which form a plurality of groups of preset mapping rules from the plurality of code blocks; the preset mapping rule includes: two code blocks separated by N bit code blocks each form a mapping relation between a previous code block and a subsequent code block, wherein N is a natural number smaller than the total number of the code blocks;
Adding check codes for checking the previous code blocks under each preset mapping rule into the corresponding subsequent code blocks; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
13. A code file verification apparatus, comprising:
The mapping rule matching module determines at least one preceding code block and a following 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 the preset mapping rule comprises the following steps: two code blocks which are separated by N bit code blocks each form a mapping relation between a preceding code block and a following code block, and a check code for checking the preceding code block is added to the following code block under a preset mapping rule, wherein N is a natural number smaller than the total number of the code blocks;
The code verification module is used for verifying the preceding code blocks under the same preset mapping rule based on the verification codes in the following code blocks under the at least one preset mapping rule; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
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:
Determining at least one preceding code block and a following code block forming a preset mapping rule from a plurality of code blocks of a code file, wherein the plurality of code blocks form a plurality of groups of preceding code blocks and following code blocks of the preset mapping rule, and the preset mapping rule comprises: two code blocks which are separated by N bit code blocks each form a mapping relation between a preceding code block and a following code block, and check codes used for checking the preceding code blocks are added to the following code blocks under each preset mapping rule, wherein N is a natural number smaller than the total number of the code blocks;
Based on the check codes in the following code blocks under the at least one preset mapping rule, checking the preceding code blocks under the same preset mapping rule; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
15. A computer readable storage medium having stored thereon a computer program which when executed by a processor performs the steps of:
Determining at least one preceding code block and a following code block forming a preset mapping rule from a plurality of code blocks of a code file, wherein the plurality of code blocks form a plurality of groups of preceding code blocks and following code blocks of the preset mapping rule, and the preset mapping rule comprises: two code blocks which are separated by N bit code blocks each form a mapping relation between a preceding code block and a following code block, and check codes used for checking the preceding code blocks are added to the following code blocks under each preset mapping rule, wherein N is a natural number smaller than the total number of the code blocks;
Based on the check codes in the following code blocks under the at least one preset mapping rule, checking the preceding code blocks under the same preset mapping rule; under the preset mapping rule, if the preceding code block is a subsequent code block of other code blocks at the same time, a check code for checking the other code blocks is added to the preceding code block; if the preceding code block is added with check codes for checking other code blocks, the check codes in the following code block corresponding to the preceding code block are used for checking the function codes and the check codes in the preceding code block.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110773908.6A CN113536310B (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 CN113536310B (en) | 2021-07-08 | 2021-07-08 | Code file processing method, code file checking device and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113536310A CN113536310A (en) | 2021-10-22 |
| CN113536310B true CN113536310B (en) | 2024-07-02 |
Family
ID=78127142
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110773908.6A Active CN113536310B (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) | CN113536310B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
Family Cites Families (10)
| 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 |
| CN103761476B (en) * | 2013-12-30 | 2016-11-09 | 北京奇虎科技有限公司 | The method and device of feature extraction |
| CN108121911B (en) * | 2016-11-30 | 2021-04-27 | 中国移动通信有限公司研究院 | Software detection method and device |
| CN108667553B (en) * | 2017-03-29 | 2021-07-09 | 华为技术有限公司 | Encoding method, decoding method, device and system |
| KR101937325B1 (en) * | 2017-10-30 | 2019-01-14 | 주식회사 시큐어링크 | Method for Detecting and Preventing Malware and Apparatus thereof |
| CN108509772B (en) * | 2018-02-12 | 2022-01-07 | 北京梆梆安全科技有限公司 | Source code reinforcement method and device based on execution sequence and single-point logic |
| CN111385057B (en) * | 2018-12-27 | 2023-05-09 | 中兴通讯股份有限公司 | Data retransmission decoding method, device, system and communication equipment |
| CN110719494B (en) * | 2019-09-06 | 2022-01-07 | 烽火通信科技股份有限公司 | Method and system for preventing CDN streaming media data from being tampered |
| CN111930555B (en) * | 2020-09-02 | 2022-12-02 | 平安国际智慧城市科技股份有限公司 | Erasure code based file processing method and device and computer equipment |
| CN116579025A (en) * | 2021-04-20 | 2023-08-11 | 支付宝(杭州)信息技术有限公司 | File storage method, device and equipment |
-
2021
- 2021-07-08 CN CN202110773908.6A patent/CN113536310B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113536310A (en) | 2021-10-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110391914B (en) | File acquisition method and equipment based on two-dimensional code and two-dimensional code generation method | |
| CN110958252B (en) | Network security device and network attack detection method, device and medium thereof | |
| CN110489466B (en) | Method and device for generating invitation code, terminal equipment and storage medium | |
| CN110717151B (en) | Digital fingerprint processing and signature processing method | |
| CN111583498A (en) | Electronic voting method, system, equipment and storage medium based on block chain | |
| CN110765441A (en) | Method, device and medium for safe login | |
| US9405936B2 (en) | Code integrity protection by computing target addresses from checksums | |
| CN112149068A (en) | Access-based authorization verification method, information generation method and device, and server | |
| CN106658034A (en) | File storage and reading method and device | |
| CN113536310B (en) | Code file processing method, code file checking device and electronic equipment | |
| CN106302414B (en) | The anti-grasping means of web site contents and device | |
| CN116680673A (en) | Identity verification method and device for display and computer equipment | |
| CN116305322A (en) | Program signature verification method and device, storage medium and electronic equipment | |
| CN111222177A (en) | Digital fingerprint processing and signature processing method | |
| CN111104662A (en) | Method for authenticating a program and corresponding integrated circuit | |
| CN111415288B (en) | Digital watermark embedding and detecting method and device | |
| CN111881047B (en) | Method and device for processing obfuscated script | |
| CN115238308A (en) | Data protection method and device, electronic equipment and storage medium | |
| CN112738006B (en) | Identification method, equipment and storage medium | |
| CN114692222A (en) | Image processing method and device | |
| CN113553626A (en) | Data integrity detection method, device, equipment and storage medium | |
| CN110825701A (en) | File type determination method and device, electronic equipment and readable storage medium | |
| CN109614807B (en) | Method and device for protecting sensitive information and readable storage medium | |
| CN117692332B (en) | Video file backup method and system | |
| CN113329032B (en) | Attack detection method, device, equipment and 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 |