CN110413283B - Confusion method based on compiler front end, storage medium and terminal equipment - Google Patents
Confusion method based on compiler front end, storage medium and terminal equipment Download PDFInfo
- Publication number
- CN110413283B CN110413283B CN201910716285.1A CN201910716285A CN110413283B CN 110413283 B CN110413283 B CN 110413283B CN 201910716285 A CN201910716285 A CN 201910716285A CN 110413283 B CN110413283 B CN 110413283B
- Authority
- CN
- China
- Prior art keywords
- clause
- files
- branch
- compiler
- blank
- 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 32
- 150000001875 compounds Chemical class 0.000 claims abstract description 31
- 238000001514 detection method Methods 0.000 claims abstract description 10
- 230000006870 function Effects 0.000 description 6
- 238000012545 processing Methods 0.000 description 5
- 238000004891 communication Methods 0.000 description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000003780 insertion Methods 0.000 description 2
- 230000037431 insertion Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 239000002131 composite material Substances 0.000 description 1
- 238000004883 computer application Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 238000000844 transformation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
- G06F8/433—Dependency analysis; Data or control flow analysis
- G06F8/434—Pointers; Aliasing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
- G06F21/14—Protecting executable software against software analysis or reverse engineering, e.g. by obfuscation
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention discloses a confusion method based on a front end of a compiler, a storage medium and terminal equipment, wherein the method comprises the following steps: C/C++ source files are analyzed by the front end of the compiler to obtain corresponding abstract syntax trees and header files contained in the source files; traversing all nodes of the abstract syntax tree, detecting whether a clause of a compound sentence has a first clause with only a single branch or not, and inserting redundant control streams according to a detection result; creating a blank file consistent with the source file type; and outputting the header files contained in the source files into blank files according to the grammar form of the header files contained in the C/C++, and outputting the top-level statement belonging to the source files in the abstract tree into the blank files according to the correct grammar form. In this way, redundant control flows are inserted through the front end of the compiler, blank files of the same type as the source file are created, and the contents in the abstract syntax tree and the header files are rewritten into the blank files, so that the code protection capability and portability are both realized.
Description
Technical Field
The present invention relates to the field of computer applications, and in particular, to a compiler front-end based obfuscation method, a storage medium, and a terminal device.
Background
The main stream design of the traditional static compiler is a three-section design, namely a front end, an optimizer and a rear end; the front end is used to analyze the source code, check for errors, and construct an abstract syntax tree for a particular language. The abstract syntax tree can be converted into codes in the middle layer representation form, and the optimizer and the back end run on the middle layer codes; the optimizer performs various transformations on the middle tier code to optimize the code, and the backend translates the middle tier code into platform specific machine instructions.
In the field of information security, the purpose of code confusion is to make the code more understandable, increase the difficulty of static analysis and prevent software from being analyzed in a malicious reverse direction; the insertion of redundant control flows is one of confusion methods, and by inserting redundant control flows into the control flow of a function, a cracker cannot reconstruct an original function control flow diagram by using a static analysis tool; the inserted control flow may or may not always be executed, and may or may not be executed at times.
The current C/C++ confusion technology is realized based on OLLVM, and the confusion is codes in the middle layer representation form; OLLVM (Obfuscator-LLVM) is an open source item aimed at providing a open source code obfuscation tool for LLVM, increasing the difficulty of reverse engineering by inserting redundant control streams; however, the result of OLLVM confusion can only be converted into machine instructions of a corresponding platform by the LLVM compiler, cannot be transplanted, and is less likely to be processed again by other compilers.
There is thus a need for improvements and improvements in the art.
Disclosure of Invention
The invention aims to solve the technical problem that aiming at the defects of the prior art, a confusion method, a storage medium and terminal equipment based on the front end of a compiler are provided to solve the problem that the confusion result of an OLLVM in the prior art cannot be compiled by other compilers and cannot be transplanted.
In order to solve the technical problems, the technical scheme adopted by the invention is as follows:
a compiler front-end based obfuscation method, comprising:
c or C++ source files are analyzed and processed by the front end of a compiler to obtain corresponding abstract syntax trees and header files contained in the source files;
traversing all nodes of the abstract syntax tree, detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and inserting redundant control streams according to detection results;
creating a C or C++ blank file consistent with the original source file type;
and outputting the header files contained in the source files into blank files according to the grammar form of the header files contained in C or C++, and outputting the top-level statement belonging to the source files in the abstract tree into the blank files according to the correct grammar form.
The step of traversing all nodes of the abstract syntax tree, the step of detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and the step of inserting redundant control flow concrete according to a detection result comprises the following steps:
if the clause of the compound sentence has a first clause with only a single branch, adding a second branch for the sentence; the content of the second branch is randomly generated or copied from a single branch and then slightly modified.
The step of traversing all nodes of the abstract syntax tree, the step of detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and the step of inserting redundant control flows according to detection results further comprises the following steps:
if the first clause does not exist in the clauses of the compound sentence, randomly selecting a group of first replaced sentences which do not contain variable declarations from the clauses, and creating a second clause to replace the group of first replaced sentences.
The control expression of the second clause is an opaque predicate which is constant true, and the content of the unique single branch in the second clause is the first replaced statement.
The step of traversing all nodes of the abstract syntax tree, the step of detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and the step of inserting redundant control flows according to detection results further comprises the following steps:
if the first clause does not exist in the clauses of the compound sentence, randomly selecting a group of second replaced sentences which do not contain variable declarations from the clauses, and creating a third clause with double branches to replace the group of second replaced sentences;
placing the second replaced into the second branch of the third clause, and placing the second replaced into the first branch of the third clause after slightly modifying the second replaced.
The control expression of the third clause is an opaque predicate that is constantly false.
The first clause, the second clause, or the third clause is an if statement.
A terminal device, comprising: a processor and a memory; the memory has stored thereon a computer readable program executable by the processor; the processor, when executing the computer readable program, implements the steps in a compiler front end based obfuscation method according to any of the previous claims.
A computer readable storage medium storing one or more programs executable by one or more processors to implement steps in a compiler front end based obfuscation method according to any of the above.
The beneficial effects are that: compared with the prior art, the invention provides a confusion method based on a front end of a compiler, a storage medium and terminal equipment, wherein the method comprises the following steps: c or C++ source files are analyzed and processed by the front end of a compiler to obtain corresponding abstract syntax trees and header files contained in the source files; traversing all nodes of the abstract syntax tree, detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and inserting redundant control streams according to detection results; creating a C or C++ blank file consistent with the original source file type; and outputting the header files contained in the source files into blank files according to the grammar form of the header files contained in C or C++, and outputting the top-level statement belonging to the source files in the abstract tree into the blank files according to the correct grammar form. In this way, redundant control flows are inserted through the front end of the compiler, a blank file consistent with the original source file type is created, and the content in the abstract syntax tree and the header file contained in the source file are rewritten into the blank file to obtain the confusing C/C++ source code, so that the code portability is realized while the code protection capability is ensured.
Drawings
FIG. 1 is a flowchart of a preferred embodiment of a compiler front-end based obfuscation method according to the present invention.
Fig. 2 is a specific flowchart of step S200 in a first embodiment of a compiler front-end based obfuscation method according to the present invention.
Fig. 3 is a specific flowchart of step S200 in a first embodiment of a compiler front-end based obfuscation method according to the present invention.
Fig. 4 is a schematic structural diagram of a preferred embodiment of the terminal device provided by the present invention.
Detailed Description
The invention relates to a compiler front-end-based confusion method, a storage medium and a terminal device, and in order to make the purposes, technical schemes and effects of the invention clearer and more definite, the invention is further described in detail below by referring to the accompanying drawings and the embodiments. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
As used herein, the singular forms "a", "an", "the" and "the" are intended to include the plural forms as well, unless expressly stated otherwise, as understood by those skilled in the art. It will be further understood that the terms "comprises" and/or "comprising," when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element or intervening elements may also be present. Further, "connected" or "coupled" as used herein may include wirelessly connected or wirelessly coupled. The term "and/or" as used herein includes all or any element and all combination of one or more of the associated listed items.
It will be understood by those skilled in the art that all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs unless defined otherwise. It will be further understood that terms, such as those defined in commonly used dictionaries, should be interpreted as having a meaning that is consistent with their meaning in the context of the prior art and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein.
The invention will be further described by the description of embodiments with reference to the accompanying drawings.
First embodiment
Referring to fig. 1, fig. 1 is a flowchart of a method for obfuscating based on a front end of a compiler, provided by the invention, the method includes:
s100, analyzing and processing the C or C++ source file by the front end of the compiler to obtain a corresponding abstract syntax tree and a header file contained in the source file.
Specifically, in the embodiment of the invention, a compiler front end analyzes and processes a C or C++ source file to obtain a corresponding abstract syntax tree, and then obtains a header file contained in the source file; and providing basic data for the following steps by using the header files contained in the abstract syntax tree and the source file obtained through analysis and processing.
S200, traversing all nodes of the abstract syntax tree, detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and inserting redundant control streams according to detection results.
Specifically, traversing all nodes of the abstract syntax tree, detecting whether a single-branch statement exists in the compound statement in the abstract syntax tree, and carrying out corresponding modification on the compound statement according to a detection result so as to realize the insertion of redundant control flow. The compound statement refers to a compound statement in a function definition, and the compound statement specifically refers to a function body or other compound statements appearing in the function body.
Accordingly, referring to fig. 2, the step S200 specifically includes:
s210, if a first clause with only a single branch exists in the clauses of the compound sentence, adding a second branch to the sentence.
Specifically, the first clause is an if statement, when an if statement with only a single branch exists, an else branch (namely a second branch) is directly added into the if statement, and the content of the else is randomly generated or copied from the single branch and then slightly changed.
The step S200 further includes:
s211, if the first clause does not exist in the clauses of the compound sentence, randomly selecting a group of first replaced sentences which do not contain variable declarations from the clauses, and creating a second clause to replace the group of first replaced sentences.
Specifically, the second clause is also an if statement, when the first clause does not exist, a group of first replaced sentences which do not contain variable declarations are randomly selected from the clauses of the compound statement, and a single-branch if statement (namely the second clause) is created to replace the group of selected sentences; in particular, the control expression of the if statement (i.e., the second clause) is an opaque predicate that is constant true, and the content of the single branch that is unique in the if statement is the set of the first replaced statement. The opaque predicate is an expression, and the value of the opaque predicate can only be determined at runtime, and is difficult to statically analyze.
S300, creating a C or C++ blank file consistent with the original source file type.
Specifically, if the original source file is a C file, the blank file is a C file, and if the original source file is a c++ file, the blank file is a c++ file.
S400, outputting header files contained in the source files into blank files according to grammar forms of the header files contained in C or C++, and outputting top-level statement belonging to the source files in the abstract tree into the blank files according to correct grammar forms.
Specifically, a C or C++ blank file with the same type as the original source file is created, a header file contained in the source file is output to the blank file according to the grammar form of the header file contained in the C or C++, and a top level statement belonging to the source file in an abstract grammar tree is output to the blank file in the correct grammar form; because the C or C++ source code has stronger portability, the program after confusion processing can be compiled by various compilers at the same time, and the portability is enhanced.
The outputting of the header file into the blank file according to the syntax form of C or c++ includes: the original source file is expressed in a grammar sentence form containing the header file, and writing is also carried out in a grammar sentence form containing the header file in the blank file after confusion (for example, the original source file is: # include < stdio.h >, and the confused source file is also # include < stdio.h >); the top level declarations belonging to the source file in the abstract syntax tree are similarly written into the blank file in the original syntax form, but the content is confusing.
Second embodiment
With continued reference to fig. 1, a flowchart of a second embodiment of a compiler front-end-based obfuscation method according to the present invention includes:
s100, analyzing and processing the C or C++ source file by the front end of the compiler to obtain a corresponding abstract syntax tree and a header file contained in the source file.
S200, traversing all nodes of the abstract syntax tree, detecting whether a first clause with only a single branch exists in clauses of the compound sentence, and inserting redundant control streams according to detection results.
Accordingly, referring to fig. 3, the step S200 specifically includes:
s210, if a first clause with only a single branch exists in the clauses of the compound sentence, adding a second branch to the sentence.
Specifically, the step S200 further includes a step of another embodiment:
s211, if the first clause does not exist in the clauses of the compound sentence, randomly selecting a group of second replaced sentences which do not contain variable declarations from the clauses, and creating a third clause with double branches to replace the group of second replaced sentences;
s212, placing the second replaced into the second branch of the third clause, and placing the second replaced into the first branch of the third clause after slightly changing the second replaced.
Specifically, when a first clause does not exist in a compound sentence in the abstract syntax tree, randomly selecting a group of second replaced sentences which do not contain variable declarations, creating a double-branch third clause to replace the group of second replaced sentences, placing the group of second replaced sentences into the second branch of the third clause, and placing the changed group of second replaced sentences into the first branch of the third clause; in particular, the third clause is an if statement, the second branch of the third clause is an eles statement, and the control expression of the third clause is an opaque predicate that is constantly false. It should be noted that the opaque predicate is an expression whose value can only be determined at runtime, and is difficult to statically analyze.
S300, creating a C or C++ blank file consistent with the original source file type;
s400, outputting header files contained in the source files into blank files according to grammar forms of the header files contained in C or C++, and outputting top-level statement belonging to the source files in the abstract tree into the blank files according to correct grammar forms.
Note that the first clause, the second clause, or the third clause is an if statement, the first clause is if (expression) state, the modified form is if (expression) statment else statement, the second clause is if (expression) state, and the third clause is if (expression) statment else statement.
The technical solution of the present application is further explained below by taking if statements as examples for the first clause, the second clause and the third clause:
example one
The codes before confusion are:
when detecting that the clause of the compound sentence has a first clause with only a single branch (namely, the clause of the if sentence has a single branch), inserting an else branch for the if sentence.
The replaced code is specifically as follows:
the second branch is inserted into the if statement as redundant control flow, so that the aim of code confusion is fulfilled.
Example two
The codes before confusion are:
traversing each node of the abstract tree, when detecting that the first clause with only a single branch does not exist in all the clauses of the compound sentence, randomly selecting a group of clauses without variable declaration in the compound sentence, namely 'printf (' argb is:% d\n ', b)', 'a=a+1', 'b=b+1', and 'r=a-b', and creating a second clause (here, an if sentence) to replace the group of clauses, wherein the content of the if sentence is the replaced group of clauses.
The replaced code is specifically as follows:
example three
The codes before confusion are:
traversing each node of the abstract tree, when detecting that a first clause with only a single branch does not exist in all clauses of the compound sentence, randomly selecting a group of clauses without variable declarations in the compound sentence, namely 'b=b+1' and 'r=a-b' in the example, creating a third clause with double branches (here, if clauses), replacing the group of clauses, modifying the replaced group of clauses, putting the replaced group of clauses into the first branch of the if clause, and directly putting the replaced group of clauses into the second branch (namely, else clause) of the if clause of the first branch of the if clause; in particular, in order to enhance the confusion effect, some statements that do not have any actual influence on the program may also be inserted into the second branch.
The replaced code is specifically as follows:
a terminal device, comprising: a processor and a memory; the memory has stored thereon a computer readable program executable by the processor; the processor, when executing the computer readable program, implements the steps in a compiler front end based obfuscation method according to any of the previous claims.
A computer readable storage medium storing one or more programs executable by one or more processors to implement steps in a compiler front end based obfuscation method according to any of the above.
In summary, the invention modifies the composite sentence on the abstract syntax tree, inserts a plurality of redundant control flows for confusion, converts the abstract syntax tree into C or C++ source code again after modification, and outputs the C or C++ source code to the newly built C or C++ blank file, so that the developer can intuitively feel the confused result, more importantly, the C/C++ source code is obtained after confusion, can be compiled by various compilers and can be transplanted to various platforms, and the code protection can be realized while the good portability can be maintained.
The present invention also provides a computer readable storage medium storing one or more programs executable by one or more processors to implement the steps in a compiler front end based obfuscation method according to the above embodiments.
The present invention also provides a terminal device, as shown in fig. 3, comprising at least one processor (processor) 20; a display screen 21; and a memory (memory) 22, which may also include a communication interface (Communications Interface) 23 and a bus 24. Wherein the processor 20, the display 21, the memory 22 and the communication interface 23 may communicate with each other via a bus 24. The display screen 21 is configured to display a user guidance interface preset in the initial setting mode. The communication interface 23 may transmit information. The processor 20 may invoke logic instructions in the memory 22 to perform the methods of the embodiments described above.
Further, the logic instructions in the memory 22 described above may be implemented in the form of software functional units and stored in a computer readable storage medium when sold or used as a stand alone product.
The memory 22, as a computer readable storage medium, may be configured to store a software program, a computer executable program, such as program instructions or modules corresponding to the methods in the embodiments of the present disclosure. The processor 30 performs the functional applications and data processing, i.e. implements the methods of the embodiments described above, by running software programs, instructions or modules stored in the memory 22.
The memory 22 may include a storage program area that may store an operating system, at least one application program required for functions, and a storage data area; the storage data area may store data created according to the use of the terminal device, etc. In addition, the memory 22 may include high-speed random access memory, and may also include nonvolatile memory. For example, a plurality of media capable of storing program codes such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a magnetic disk, or an optical disk, or a transitory storage medium may be used.
In addition, the specific processes that the storage medium and the plurality of instruction processors in the mobile terminal load and execute are described in detail in the above method, and are not stated here.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and are not limiting; although the invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present invention.
Claims (4)
1. A compiler front-end based obfuscation method, comprising:
c or C++ source files are analyzed and processed by the front end of a compiler to obtain corresponding abstract syntax trees and header files contained in the source files;
traversing all nodes of the abstract syntax tree, detecting whether a first clause with only a single branch exists in clauses of a compound sentence, and inserting redundant control streams according to detection results, wherein the steps comprise;
if the clause of the compound sentence has a first clause with only a single branch, adding a second branch for the clause; if the first clause does not exist in the clauses of the compound sentence, randomly selecting a group of second replaced sentences which do not contain variable declarations from the clauses, and creating a third clause with double branches to replace the group of second replaced sentences; placing the second replaced sentence into a second branch of a third clause, slightly changing the second replaced sentence, and then placing the second replaced sentence into a first branch of the third clause, wherein the first clause and the third clause are if sentences, the second branch of the third clause is eles sentences, and a control expression of the third clause is an opaque predicate with constant false;
creating a C or C++ blank file consistent with the original source file type;
and outputting the header files contained in the source files into blank files according to the grammar form of the header files contained in C or C++, and outputting the top-level statement belonging to the source files in the abstract tree into the blank files according to the correct grammar form.
2. The compiler-front-end based obfuscation method according to claim 1, wherein the contents of the second branch are randomly generated or copied from a single branch and then slightly altered.
3. A terminal device, comprising: a processor and a memory; the memory has stored thereon a computer readable program executable by the processor; the processor, when executing the computer readable program, implements the steps of the compiler front-end based obfuscation method according to any of claims 1-2.
4. A computer readable storage medium storing one or more programs executable by one or more processors to implement the steps in the compiler front end based obfuscation method according to any of claims 1-2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910716285.1A CN110413283B (en) | 2019-08-02 | 2019-08-02 | Confusion method based on compiler front end, storage medium and terminal equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910716285.1A CN110413283B (en) | 2019-08-02 | 2019-08-02 | Confusion method based on compiler front end, storage medium and terminal equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110413283A CN110413283A (en) | 2019-11-05 |
| CN110413283B true CN110413283B (en) | 2023-05-30 |
Family
ID=68365693
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910716285.1A Active CN110413283B (en) | 2019-08-02 | 2019-08-02 | Confusion method based on compiler front end, storage medium and terminal equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110413283B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113031930B (en) * | 2019-12-24 | 2022-07-05 | 武汉斗鱼鱼乐网络科技有限公司 | Source code confusion generation method and device for control flow flattening |
| CN113391817B (en) * | 2021-06-16 | 2022-08-26 | 中国海洋大学 | ANTLR 4-based header file replacement method and device |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107229848A (en) * | 2017-06-12 | 2017-10-03 | 北京洋浦伟业科技发展有限公司 | A kind of code reinforcement means and device |
| CN107632832A (en) * | 2017-09-27 | 2018-01-26 | 电子科技大学 | One kind obscures method towards dalvik bytecode controlling streams |
| CN108710787A (en) * | 2018-03-26 | 2018-10-26 | 江苏通付盾信息安全技术有限公司 | Code obfuscation method and device, computing device, computer storage media |
| CN109992935A (en) * | 2019-03-15 | 2019-07-09 | 同盾控股有限公司 | A kind of source code guard method and device |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8589897B2 (en) * | 2008-08-26 | 2013-11-19 | Apple Inc. | System and method for branch extraction obfuscation |
-
2019
- 2019-08-02 CN CN201910716285.1A patent/CN110413283B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107229848A (en) * | 2017-06-12 | 2017-10-03 | 北京洋浦伟业科技发展有限公司 | A kind of code reinforcement means and device |
| CN107632832A (en) * | 2017-09-27 | 2018-01-26 | 电子科技大学 | One kind obscures method towards dalvik bytecode controlling streams |
| CN108710787A (en) * | 2018-03-26 | 2018-10-26 | 江苏通付盾信息安全技术有限公司 | Code obfuscation method and device, computing device, computer storage media |
| CN109992935A (en) * | 2019-03-15 | 2019-07-09 | 同盾控股有限公司 | A kind of source code guard method and device |
Non-Patent Citations (1)
| Title |
|---|
| 基于Clang的C++代码混潜工具设计与实现;张清泉;《中国优秀硕士学位论文全文数据库 （基础科学辑）》;20150415;第5-53页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110413283A (en) | 2019-11-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112100054B (en) | Data management and control oriented program static analysis method and system | |
| US8589897B2 (en) | System and method for branch extraction obfuscation | |
| CN108614960B (en) | JavaScript virtualization protection method based on front-end byte code technology | |
| US8850414B2 (en) | Direct access of language metadata | |
| CN108139891B (en) | Method and system for generating suggestions to correct undefined token errors | |
| ES2733516T3 (en) | Verification of limits at compile time for user-defined types | |
| US20210279045A1 (en) | Integrated development environment for developing and compiling query language schemas for application program interfaces | |
| CN110569628B (en) | Code obfuscation method and device, computer device and storage medium | |
| WO1996013784A2 (en) | Method and apparatus for tree data structure manipulation and translating source code from one high-level computer language to another | |
| WO1996013784A9 (en) | Method and apparatus for tree data structure manipulation and translating source code from one high-level computer language to another | |
| US8464232B2 (en) | Compiler compiler system with syntax-controlled runtime and binary application programming interfaces | |
| CN110673852B (en) | Method, system and equipment for realizing control flow flattening based on front end of compiler | |
| CN110413283B (en) | Confusion method based on compiler front end, storage medium and terminal equipment | |
| US20140053285A1 (en) | Methods for detecting plagiarism in software code and devices thereof | |
| KR101356676B1 (en) | Translating expressions in a computing environment | |
| CN114625844B (en) | Code searching method, device and equipment | |
| Nichols et al. | Structural and nominal cross-language clone detection | |
| US8914782B2 (en) | Optimization of declarative queries | |
| JP6651974B2 (en) | Information processing apparatus, compiling method and compiler program | |
| Kabanov et al. | Embedded typesafe domain specific languages for Java | |
| US10275228B2 (en) | Relaxing user-specified register constraints for improving register allocation | |
| Bagge et al. | A pretty good formatting pipeline | |
| Aladjev et al. | Extension of Mathematica system functionality | |
| Visser | Understanding software through linguistic abstraction | |
| CN111796832A (en) | Hot patch file generation method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |