CN117436040B - Opaque predicate-based code confusion method, system and storage medium - Google Patents
Opaque predicate-based code confusion method, system and storage medium Download PDFInfo
- Publication number
- CN117436040B CN117436040B CN202311734001.4A CN202311734001A CN117436040B CN 117436040 B CN117436040 B CN 117436040B CN 202311734001 A CN202311734001 A CN 202311734001A CN 117436040 B CN117436040 B CN 117436040B
- Authority
- CN
- China
- Prior art keywords
- predicate
- opaque
- constructing
- symbol
- array
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 35
- 238000010276 construction Methods 0.000 claims abstract description 22
- 230000002787 reinforcement Effects 0.000 claims abstract description 6
- 230000014509 gene expression Effects 0.000 claims description 24
- 238000003780 insertion Methods 0.000 claims description 6
- 230000037431 insertion Effects 0.000 claims description 6
- 238000004590 computer program Methods 0.000 claims description 3
- 238000001514 detection method Methods 0.000 abstract description 4
- 230000006870 function Effects 0.000 description 11
- 238000004458 analytical method Methods 0.000 description 5
- 238000003491 array Methods 0.000 description 3
- 238000011160 research Methods 0.000 description 3
- 238000004422 calculation algorithm Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 1
- 238000005291 chaos (dynamical) Methods 0.000 description 1
- 238000005336 cracking Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000011156 evaluation Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000007493 shaping process Methods 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
- G06F21/14—Protecting executable software against software analysis or reverse engineering, e.g. by obfuscation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/268—Morphological analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/279—Recognition of textual entities
- G06F40/284—Lexical analysis, e.g. tokenisation or collocates
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Software Systems (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Computer Security & Cryptography (AREA)
- Computer Hardware Design (AREA)
- Technology Law (AREA)
- Multimedia (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a code confusion method based on opaque predicates, which comprises the following steps: acquiring a basic block set corresponding to codes to be confused in a control flow graph of a program; constructing a predicate basic block set, and inserting redundant basic blocks; constructing an opaque predicate set; and performing opaque predicate reinforcement operation on the predicate basic block after the redundant basic block is inserted by using the opaque predicate. The opaque predicate construction method can not only greatly improve the complexity of the opaque predicate, but also cause missing report when the opaque predicate is detected by symbol execution, thereby effectively resisting symbol execution detection attack.
Description
Technical Field
The invention belongs to the technical field of software detection, and relates to a code confusion method, a system and a storage medium based on opaque predicates.
Background
In programming, conditional statements are used to choose to execute certain blocks of code or jump to different blocks of code depending on the particular condition, each conditional branch having the possibility of being executed. However, opaque predicates introduce redundant branches to complicate the control flow graph by building branch structures using remarks or contradictions as conditional statements. In actual execution, these redundant branches are never executed, and the instructions in the basic blocks they connect are invalid instructions, simply to increase the difficulty of understanding the program and to confuse the control flow.
Opaque predicate obfuscation is mainly used to protect key codes of programs against reverse analysis and to prevent code theft. Opaque predicates are widely applied to software protection as a code confusion technology, and students have conducted related researches on the opaque predicates, and various construction methods of the opaque predicates are respectively provided from the aspects of residual theory, number theory, chaos theory and the like. The Collberg et al firstly propose a construction method for constructing two opaque predicates, namely an alias construction method and a concurrency construction method, so that the cracking difficulty of the opaque predicates is increased to a certain extent. The method parameterizes predicates to construct more complex predicates, but has the defects of too simple form and poor safety, and Myles show that the safety of constructing the opaque predicates by using secondary residual is poor through experimental tests and evaluation. Yuan Zheng et al propose an opaque predicate construction method based on congruence equations through elementary theory, and the method has more superiority in terms of safety and cost overhead compared with a quadratic residue mode. However, such opaque predicates are easier to filter during the reverse analysis.
At present, most opaque predicate construction technologies focus on research on predicate complexity, and hide predicate internal logic through complex mathematical transformation, so that the predicate has better static reverse analysis resistance. However, when faced with dynamic analysis, the aliasing effects of these traditional opaque predicates are not ideal.
Disclosure of Invention
The invention aims to provide a code confusion method, a system and a storage medium based on opaque predicates, wherein the opaque predicates are constructed by double-array mixed calculation, and the opaque predicate construction method not only can greatly improve the complexity of the opaque predicates, but also can cause missing report when a symbol execution detects the opaque predicates, so that symbol execution detection attack is effectively resisted.
The technical solution for realizing the purpose of the invention is as follows:
a method of opaque predicate-based code obfuscation, comprising the steps of:
s01: acquiring a basic block set corresponding to codes to be confused in a control flow graph of a program;
s02: constructing a predicate basic block set, and inserting redundant basic blocks;
s03: constructing an opaque predicate set;
s04: and performing opaque predicate reinforcement operation on the predicate basic block after the redundant basic block is inserted by using the opaque predicate.
In a preferred technical solution, in the step S02, a predicate basic block set is constructed, and the method for inserting the redundant basic block includes:
s11: respectively inserting conditional predicate expressions into each basic block in the basic block set to construct a predicate basic block set;
s12: constructing a corresponding pluggable redundant basic block set according to the predicate basic block set;
s13: searching corresponding redundant basic blocks in the redundant basic block set, and performing redundant basic block insertion operation on the predicate basic blocks.
In a preferred embodiment, the method for constructing the opaque predicate set in step S03 includes:
s31: constructing a first symbol array, wherein the array elements of the first symbol array take values according to an increasing rule and a 2 times relation;
s32: constructing a second symbol array, wherein the array elements of the second symbol array take values according to an increasing rule and at least 1 multiple relation;
s33: constructing a first symbol variable, wherein the value of the first symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array and array elements in the second symbol array;
s34: constructing a second symbol variable, wherein the value of the second symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array/the second symbol array;
s35: opaque predicates are constructed, the expressions of which are composed of constructed first symbolic variables and second symbolic variables, the expressions of which are unequal expressions, and the expression values of which are permanently false.
In a preferred embodiment, the length of the first symbol array is 8, and the first symbol array a [ ] = {0,2,4,6,8,10,12,14}.
In a preferred embodiment, the length of the second symbol array is 8, and the second symbol array b [ ] = {0,1,2,3,4,5,6,7}.
In a preferred embodiment, the method for constructing the first symbolic variable includes:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
dividing 8 by the third symbol variable x to obtain a remainder operation as the subscript of the first symbol array a [ ], dividing 2 by the obtained value to obtain a whole value as the subscript of the first symbol array a [ ], and performing AND operation on the obtained element value and the array element a [7 ];
and performing OR operation on the operation result and the group element b [1], namely y= (a [ (a [ x%8 ])/2 ] & a [7 ])|b1 ], wherein y is a first symbol variable.
In a preferred embodiment, the method for constructing the second symbolic variable includes:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
and dividing 8 by the third symbol variable x to obtain remainder operation as the subscript of the array a [ ], and then carrying out addition operation on the obtained element value and the constant 1.
The invention also discloses a code confusion system based on opaque predicates, which comprises:
the basic block acquisition module acquires a basic block set corresponding to codes to be confused in a control flow graph of a program;
the redundant basic block insertion module constructs a predicate basic block set and inserts the redundant basic blocks;
an opaque predicate construction module that constructs an opaque predicate set;
and the code confusion module uses opaque predicates to carry out opaque predicate reinforcement operation on the predicate basic blocks after the redundant basic blocks are inserted.
In a preferred technical solution, the method for constructing the opaque predicate set in the opaque predicate construction module includes:
s31: constructing a first symbol array, wherein the array elements of the first symbol array take values according to an increasing rule and a 2 times relation;
s32: constructing a second symbol array, wherein the array elements of the second symbol array take values according to an increasing rule and at least 1 multiple relation;
s33: constructing a first symbol variable, wherein the value of the first symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array and array elements in the second symbol array;
s34: constructing a second symbol variable, wherein the value of the second symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array/the second symbol array;
s35: opaque predicates are constructed, the expressions of which are composed of constructed first symbolic variables and second symbolic variables, the expressions of which are unequal expressions, and the expression values of which are permanently false.
The invention also discloses a computer storage medium, on which a computer program is stored, which when executed implements the opaque predicate-based code obfuscation method described above.
Compared with the prior art, the invention has the remarkable advantages that:
the invention uses the symbol variable and the double-symbol array, and performs mixed operation to construct the opaque predicate through the elements in the symbol variable and the double-symbol array, and the opaque predicate construction method not only can greatly improve the complexity of the opaque predicate, but also can cause the missing report when the symbol execution detects the opaque predicate, thereby effectively resisting the symbol execution detection attack.
The method can greatly improve the strength of opaque predicates and effectively increase the elasticity of the opaque predicates against dynamic reverse analysis of programs.
Drawings
FIG. 1 is a flow chart of a method of opaque predicate-based code obfuscation of the present embodiment;
fig. 2 is a schematic block diagram of a code obfuscation system based on opaque predicates according to the present embodiment.
Detailed Description
The principle of the invention is as follows: the invention uses the symbol variable and the double-symbol array, and performs mixed operation to construct the opaque predicate through the elements in the symbol variable and the double-symbol array, and the opaque predicate construction method not only can greatly improve the complexity of the opaque predicate, but also can cause the missing report when the symbol execution detects the opaque predicate, thereby effectively resisting the symbol execution detection attack.
Example 1:
as shown in fig. 1, a code obfuscation method based on opaque predicates includes the steps of:
s01: acquiring a basic block set corresponding to codes to be confused in a control flow graph of a program;
s02: constructing a predicate basic block set, and inserting redundant basic blocks;
s03: constructing an opaque predicate set;
s04: and performing opaque predicate reinforcement operation on the predicate basic block after the redundant basic block is inserted by using the opaque predicate.
In a preferred embodiment, the method for constructing the predicate basic block set and inserting the redundant basic block in step S02 includes:
s11: respectively inserting conditional predicate expressions into each basic block in the basic block set to construct a predicate basic block set;
s12: constructing a corresponding pluggable redundant basic block set according to the predicate basic block set;
s13: searching corresponding redundant basic blocks in the redundant basic block set, and performing redundant basic block insertion operation on the predicate basic blocks.
In a preferred embodiment, the method for constructing the opaque predicate set in step S03 includes:
s31: constructing a first symbol array, wherein the array elements of the first symbol array take values according to an increasing rule and a 2 times relation;
s32: constructing a second symbol array, wherein the array elements of the second symbol array take values according to an increasing rule and at least 1 multiple relation;
s33: constructing a first symbol variable, wherein the value of the first symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array and array elements in the second symbol array;
s34: constructing a second symbol variable, wherein the value of the second symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array/the second symbol array;
s35: opaque predicates are constructed, the expressions of which are composed of constructed first symbolic variables and second symbolic variables, the expressions of which are unequal expressions, and the expression values of which are permanently false.
In a preferred embodiment, the first symbol array has a length of 8, and the first symbol array a [ ] = {0,2,4,6,8,10,12,14}.
In a preferred embodiment, the second symbol array has a length of 8, and the second symbol array b [ ] = {0,1,2,3,4,5,6,7}.
In a preferred embodiment, the method of constructing the first symbolic variable includes:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
dividing 8 by the third symbol variable x to obtain a remainder operation as the subscript of the first symbol array a [ ], dividing 2 by the obtained value to obtain a whole value as the subscript of the first symbol array a [ ], and performing AND operation on the obtained element value and the array element a [7 ];
and performing OR operation on the operation result and the group element b [1], namely y= (a [ (a [ x%8 ])/2 ] & a [7 ])|b1 ], wherein y is a first symbol variable.
In a preferred embodiment, the method of constructing the second symbolic variable comprises:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
and dividing 8 by the third symbol variable x to obtain remainder operation as the subscript of the array a [ ], and then carrying out addition operation on the obtained element value and the constant 1.
In another embodiment, a computer storage medium has a computer program stored thereon that, when executed, implements the opaque predicate-based code obfuscation method described above.
In another embodiment, as shown in FIG. 2, a code obfuscation system based on opaque predicates, includes:
the basic block acquisition module 10 acquires a basic block set corresponding to codes to be confused in a control flow graph of a program;
a redundant basic block insertion module 20 for constructing a predicate basic block set and inserting a redundant basic block;
an opaque predicate construction module 30 that constructs an opaque predicate set;
the code obfuscation module 40 performs an opaque predicate hardening operation on the predicate basic block after the redundant basic block is inserted using an opaque predicate.
Specifically, the workflow of the opaque predicate-based code obfuscation system is described below by taking a preferred embodiment as an example:
the method specifically comprises the following steps:
1. and constructing a program control flow graph according to the program before confusion.
2. Traversing a program control flow diagram, and selecting a basic block set corresponding to codes needing confusion protection in a program on the basis of analyzing the program control flow structure。
3. For basic block setIs inserted with conditional predicate expressions +.>Constructing a predicate basic block set ++>。
4. For predicate basic block setConstructing corresponding insertable redundant basic block set +.>。
5. For each of the attributesPredicate basic block +.>Searching for corresponding redundancy baseThe block performs the operation of inserting the redundant basic block: />。
6. For predicate basic block after inserting redundant basic blockOpaque predicate hardening operations are performed:constructing a confusing program execution flow, wherein +.>An opaque predicate hardening method is represented.
7. Returning to the obfuscated program.
The invention uses the symbolic variable and the double-symbolic array, and constructs the opaque predicate through the mixed operation of the elements in the symbolic variable and the double-symbolic array, and the constructed algorithm is described as follows.
(1) The shaping parameter p of the protected function is read.
(2) A symbolic variable x is defined and p is assigned to the defined symbolic variable, e.g. "int x=p".
(3) Defining a symbol array a [ ] with array length of 8, assigning size to the symbol array and initializing the number of arrays. The array elements are valued according to the relation of increasing rule and 2 times, and the values of the array elements are a [ ] = {0,2,4,6,8,10,12,14}, respectively.
(4) Defining a symbol array b [ ] with array length of 8, assigning size to symbol array and initializing number of arrays. The array elements are valued according to the relation of increasing rule and 1 multiple, and the values are b [ ] = {0,1,2,3,4,5,6,7}, respectively.
(5) Defining a symbol variable y, wherein y is one of conditions for constructing opaque predicates, the construction of y needs to be specifically operated according to the sizes, the numbers and the rules of array element values of symbol arrays a and b, namely 'y= (a [ (a [ x%8 ])/2 ] & a [7 ])|b1 ]', the construction of y comprises the steps that the symbol variable x is divided by 8 to be used as a subscript of an array a [ ], the obtained value is divided by 2 to be used as a subscript of the array a [ ], the obtained element value is subjected to AND operation with an array element a [7], and finally, an operation result and the array element b [1] are subjected to OR operation.
(6) Defining a symbol variable z, wherein z is another condition for constructing an opaque predicate, and the construction of z needs to be specifically operated according to the size, number and rule of array element values of the symbol array a, namely 'z=a [ x%8] +1', wherein the construction of z comprises the operation of the symbol variable x as a subscript of the array, the acquired value is taken as the subscript of the array, and finally, the mixed operation is carried out between the acquired element value and the array element. The construction of z includes that the symbol variable x is divided by 8 to be used as the subscript of the array a [ ], and then the obtained element value and the constant 1 are added.
(7) Constructing a permanent false opaque predicate according to the jump relation of the program, wherein the opaque predicate needs to use y constructed in the step (5) and z constructed in the step (6). Since z is a variable that is always equivalent to y, the construction of an opaque predicate requires that y be connected with equivalent z with unequal conditions, so that the opaque predicate is permanently false, i.e., "y |=z". Thus, the symbolic execution engine cannot handle the symbolic memory, it will generate an incorrect constraint model and incorrectly identify the predicate as a normal predicate.
The technical scheme of the invention is described below by taking a function as a research object.
Specific examples of the construction based on the above primitive functions according to the opaque predicate construction algorithm are as follows:
in the above code, y |=z is an opaque predicate, and the opaque predicate is permanently false.
Dead code is inserted in the false branches to build false branches and complicate the program control flow in conjunction with opaque predicates that are constant in condition.
The foregoing examples are preferred embodiments of the present invention, but the embodiments of the present invention are not limited to the foregoing examples, and any other changes, modifications, substitutions, combinations, and simplifications that do not depart from the spirit and principles of the present invention should be made therein and are intended to be equivalent substitutes within the scope of the present invention.
Claims (8)
1. A method of code obfuscation based on opaque predicates, comprising the steps of:
s01: acquiring a basic block set corresponding to codes to be confused in a control flow graph of a program;
s02: constructing a predicate basic block set, and inserting redundant basic blocks;
s03: constructing an opaque predicate set; the method for constructing the opaque predicate set comprises the following steps:
s31: constructing a first symbol array, wherein the array elements of the first symbol array take values according to an increasing rule and a 2 times relation;
s32: constructing a second symbol array, wherein the array elements of the second symbol array take values according to an increasing rule and at least 1 multiple relation;
s33: constructing a first symbol variable, wherein the value of the first symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array and array elements in the second symbol array;
s34: constructing a second symbol variable, wherein the value of the second symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array/the second symbol array;
s35: constructing opaque predicates, wherein the expressions of the opaque predicates are composed of constructed first symbolic variables and second symbolic variables, the expressions of the opaque predicates are unequal expressions, and the expression values of the opaque predicates are permanently false;
s04: and performing opaque predicate reinforcement operation on the predicate basic block after the redundant basic block is inserted by using the opaque predicate.
2. The opaque predicate-based code obfuscation method according to claim 1, wherein the constructing a predicate basic block set in step S02, the inserting redundant basic blocks includes:
s11: respectively inserting conditional predicate expressions into each basic block in the basic block set to construct a predicate basic block set;
s12: constructing a corresponding pluggable redundant basic block set according to the predicate basic block set;
s13: searching corresponding redundant basic blocks in the redundant basic block set, and performing redundant basic block insertion operation on the predicate basic blocks.
3. The opaque predicate-based code obfuscation method of claim 1, wherein the first symbol array has a length of 8, and the first symbol array a [ ] = {0,2,4,6,8,10,12,14}.
4. The opaque predicate-based code obfuscation method of claim 1, wherein the second symbol array has a length of 8, and the second symbol array b [ ] = {0,1,2,3,4,5,6,7}.
5. The opaque predicate-based code obfuscation method of claim 1, wherein the method of constructing the first symbol variable includes:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
dividing 8 by the third symbol variable x to obtain a remainder operation as the subscript of the first symbol array a [ ], dividing 2 by the obtained value to obtain a whole value as the subscript of the first symbol array a [ ], and performing AND operation on the obtained element value and the array element a [7 ];
and performing OR operation on the operation result and the group element b [1], namely y= (a [ (a [ x%8 ])/2 ] & a [7 ])|b1 ], wherein y is a first symbol variable.
6. The opaque predicate-based code obfuscation method of claim 1, wherein the method of constructing the second symbolic variable includes:
constructing a third symbolic variable as a symbolic variable in the protected function, wherein the value of the third symbolic variable is from the integer parameter of the protected function;
and dividing 8 by the third symbol variable x to obtain remainder operation as the subscript of the array a [ ], and then carrying out addition operation on the obtained element value and the constant 1.
7. A code obfuscation system based on opaque predicates, comprising:
the basic block acquisition module acquires a basic block set corresponding to codes to be confused in a control flow graph of a program;
the redundant basic block insertion module constructs a predicate basic block set and inserts the redundant basic blocks;
an opaque predicate construction module that constructs an opaque predicate set; the method for constructing the opaque predicate set comprises the following steps:
s31: constructing a first symbol array, wherein the array elements of the first symbol array take values according to an increasing rule and a 2 times relation;
s32: constructing a second symbol array, wherein the array elements of the second symbol array take values according to an increasing rule and at least 1 multiple relation;
s33: constructing a first symbol variable, wherein the value of the first symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array and array elements in the second symbol array;
s34: constructing a second symbol variable, wherein the value of the second symbol variable is obtained by carrying out mixed operation on array elements in the first symbol array/the second symbol array;
s35: constructing opaque predicates, wherein the expressions of the opaque predicates are composed of constructed first symbolic variables and second symbolic variables, the expressions of the opaque predicates are unequal expressions, and the expression values of the opaque predicates are permanently false;
and the code confusion module uses opaque predicates to carry out opaque predicate reinforcement operation on the predicate basic blocks after the redundant basic blocks are inserted.
8. A computer storage medium having stored thereon a computer program, which when executed implements the opaque predicate-based code obfuscation method of any of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311734001.4A CN117436040B (en) | 2023-12-18 | 2023-12-18 | Opaque predicate-based code confusion method, system and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311734001.4A CN117436040B (en) | 2023-12-18 | 2023-12-18 | Opaque predicate-based code confusion method, system and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117436040A CN117436040A (en) | 2024-01-23 |
| CN117436040B true CN117436040B (en) | 2024-04-12 |
Family
ID=89551822
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311734001.4A Active CN117436040B (en) | 2023-12-18 | 2023-12-18 | Opaque predicate-based code confusion method, system and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117436040B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108446536A (en) * | 2018-02-12 | 2018-08-24 | 北京梆梆安全科技有限公司 | A kind of source code reinforcement means and device based on semiology analysis and single-point logic |
| CN108446542A (en) * | 2018-02-12 | 2018-08-24 | 南京梆梆信息科技有限公司 | A kind of source code based on semiology analysis obscures method and device |
| CN108537012A (en) * | 2018-02-12 | 2018-09-14 | 北京梆梆安全科技有限公司 | Source code based on variable and code execution sequence obscures method and device |
| CN109409036A (en) * | 2018-09-19 | 2019-03-01 | 苏州创旅天下信息技术有限公司 | Control stream based on redundant code obscures method and device, storage medium and terminal |
| CN112733193A (en) * | 2021-01-22 | 2021-04-30 | 福州大学 | Auditable anonymity predicate retrieval system and method based on time control |
| CN115017516A (en) * | 2022-06-02 | 2022-09-06 | 电子科技大学 | Fuzzy test method based on symbolic execution |
| CN116126335A (en) * | 2022-11-21 | 2023-05-16 | 中国人民解放军战略支援部队信息工程大学 | Opaque predicate code confusion device and method based on floating point number type conversion and operation |
-
2023
- 2023-12-18 CN CN202311734001.4A patent/CN117436040B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108446536A (en) * | 2018-02-12 | 2018-08-24 | 北京梆梆安全科技有限公司 | A kind of source code reinforcement means and device based on semiology analysis and single-point logic |
| CN108446542A (en) * | 2018-02-12 | 2018-08-24 | 南京梆梆信息科技有限公司 | A kind of source code based on semiology analysis obscures method and device |
| CN108537012A (en) * | 2018-02-12 | 2018-09-14 | 北京梆梆安全科技有限公司 | Source code based on variable and code execution sequence obscures method and device |
| CN109409036A (en) * | 2018-09-19 | 2019-03-01 | 苏州创旅天下信息技术有限公司 | Control stream based on redundant code obscures method and device, storage medium and terminal |
| CN112733193A (en) * | 2021-01-22 | 2021-04-30 | 福州大学 | Auditable anonymity predicate retrieval system and method based on time control |
| CN115017516A (en) * | 2022-06-02 | 2022-09-06 | 电子科技大学 | Fuzzy test method based on symbolic execution |
| CN116126335A (en) * | 2022-11-21 | 2023-05-16 | 中国人民解放军战略支援部队信息工程大学 | Opaque predicate code confusion device and method based on floating point number type conversion and operation |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117436040A (en) | 2024-01-23 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Warga | Optimal control of differential and functional equations | |
| Berman | Relationship between density and deterministic complexity of MP-complete languages | |
| Larson | The stationary tower: Notes on a course by W. Hugh Woodin | |
| Aydin et al. | On the new sequence spaces which include the spaces c0 and c | |
| Huang et al. | Self-stabilizing depth-first token circulation on networks | |
| CN104079304B (en) | For handling the device and method of data | |
| Yu et al. | Symbolic string verification: Combining string analysis and size analysis | |
| CN107632832B (en) | Dalvik byte code oriented control flow confusion method | |
| CN117436040B (en) | Opaque predicate-based code confusion method, system and storage medium | |
| Valk | On the computational power of extended Petri nets | |
| CN107437005A (en) | A kind of Code obfuscation method and device based on the opaque predicate of chaos | |
| Slaman et al. | Algebraic aspects of the computably enumerable degrees. | |
| Hirokawa et al. | A new and formalized proof of abstract completion | |
| Huffman | A purely definitional universal domain | |
| Kirchner | Schematization of infinite sets of rewrite rules. Application to the divergence of completion processes | |
| Zhou | Symmetric graphs and flag graphs | |
| Baier et al. | The algebraic mu-calculus and MTBDDs | |
| Dunaev | Complexity of a special deobfuscation problem | |
| Stanat | A homomorphism theorem for weighted context-free grammars | |
| Varpaaniemi | On computing symmetries and stubborn sets | |
| CN103399982A (en) | Digital hardware circuit logical error diagnosis mechanism | |
| CN117270878B (en) | Constraint condition extraction method and device for program variables in program execution path | |
| Mukund et al. | Symbolic bisimulation using tabled constraint logic programming | |
| CN114780920A (en) | Non-size-constraint opaque predicate construction method and system and storage medium | |
| Langille et al. | Sequential vs. parallel complexity in simple gene assembly |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |