CN110569628B - Code obfuscation method and device, computer device and storage medium - Google Patents
Code obfuscation method and device, computer device and storage medium Download PDFInfo
- Publication number
- CN110569628B CN110569628B CN201910864925.3A CN201910864925A CN110569628B CN 110569628 B CN110569628 B CN 110569628B CN 201910864925 A CN201910864925 A CN 201910864925A CN 110569628 B CN110569628 B CN 110569628B
- Authority
- CN
- China
- Prior art keywords
- syntax tree
- abstract syntax
- source file
- node
- nodes
- 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
- 230000014509 gene expression Effects 0.000 claims description 41
- 238000004590 computer program Methods 0.000 claims description 14
- 230000004048 modification Effects 0.000 claims description 4
- 238000012986 modification Methods 0.000 claims description 4
- 230000008569 process Effects 0.000 claims description 4
- 238000006243 chemical reaction Methods 0.000 claims description 3
- 238000010586 diagram Methods 0.000 description 3
- 230000006870 function Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 2
- 238000005336 cracking Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 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
- 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
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/425—Lexical analysis
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Multimedia (AREA)
- Technology Law (AREA)
- Computer Hardware Design (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application relates to a code obfuscation method, a code obfuscation device, a computer device and a storage medium, wherein the method comprises the following steps: acquiring a first abstract syntax tree corresponding to a first source file; modifying the first abstract syntax tree to obtain a second abstract syntax tree; converting the second abstract syntax tree into a second source file. The method is used for obfuscating the codes, and the obfuscated codes can still be compiled by various compilers and can also be transplanted to various platforms.
Description
Technical Field
The present application relates to the field of computers, and in particular, to a method and an apparatus for obfuscating a code, a computer device, and a storage medium.
Background
In the field of mobile information security, the purpose of code obfuscation is to make code more illegible and to prevent software from being reverse analyzed by malicious intent.
In the related art, a middle layer of a LLVM (Low Level Virtual Machine, abbreviated as LLVM) compiler is used to obfuscate code. The mainstream design of the conventional static compiler is a three-stage design, which is a front end, an optimizer (also called middle layer) and a back end. The front end analyzes the source code, checks errors, and constructs an abstract syntax tree of a specific language. The abstract syntax tree may be translated into code in the form of a middle layer representation on which the optimizer and backend run. The optimizer performs various transformations on the middle layer code to optimize the code for lines, and the back end translates the middle layer code into platform-specific machine instructions. And the middle layer of the LLVM compiler is used for obfuscating the codes, and the codes can only be converted into machine instructions of a corresponding platform by the LLVM compiler, so that the obfuscated codes cannot be transplanted and cannot be processed again by other compilers.
Therefore, the prior art is in need of improvement.
Disclosure of Invention
The technical problem to be solved by the present application is that in the existing code obfuscating method, only the LLVM compiler can be converted into the machine instruction of the corresponding platform, so that the obfuscated code cannot be transplanted and cannot be processed again by other compilers.
In a first aspect, an embodiment of the present application provides a method for obfuscating a code, where the method includes: acquiring a first abstract syntax tree corresponding to a first source file; modifying the first abstract syntax tree to obtain a second abstract syntax tree; converting the second abstract syntax tree into a second source file.
Optionally, obtaining a first abstract syntax tree corresponding to the first source file includes: and analyzing and processing the first source file by the front end of the compiler to obtain the first abstract syntax tree corresponding to the first source file and a header file contained in the first source file.
Optionally, modifying the first abstract syntax tree to obtain a second abstract syntax tree, including:
traversing nodes in the first abstract syntax tree; judging whether the node is of a replaceable type; and if so, replacing the nodes in the first abstract syntax tree with equivalent expressions.
Optionally, the alternative types include: arithmetic operation expressions, bit operation expressions.
Optionally, converting the second abstract syntax tree into a second source file comprises: creating a blank source file, the blank source file being of the same type as the first source file; and outputting a header file contained in the first source file to the blank source file according to a syntactic form, and outputting a top-level statement in the second abstract syntactic tree to the blank source file according to a syntactic form to obtain the second source file.
Optionally, the compiler is an LLVM.
In a second aspect, an embodiment of the present application provides an obfuscating apparatus for a code, including:
the obtaining unit is used for obtaining a first abstract syntax tree in a first source file;
the modification unit is used for modifying the abstract syntax tree to obtain a second abstract syntax tree;
a conversion unit, configured to convert the second abstract syntax tree into a second source file.
Optionally, the modifying unit includes: a traversing module for traversing nodes in the first abstract syntax tree; the judging module is used for judging whether the node is of a replaceable type; and the replacing module is used for replacing the nodes in the first abstract syntax tree with equivalent expressions if the judgment result is yes.
In a third aspect, an embodiment of the present application provides a computer device, including a memory and a processor, where the memory stores a computer program, and the processor implements the following steps when executing the computer program:
acquiring a first abstract syntax tree corresponding to a first source file;
modifying the first abstract syntax tree to obtain a second abstract syntax tree;
converting the second abstract syntax tree into a second source file.
In a fourth aspect, an embodiment of the present application further provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the following steps:
acquiring a first abstract syntax tree corresponding to a first source file;
modifying the first abstract syntax tree to obtain a second abstract syntax tree;
converting the second abstract syntax tree into a second source file.
Compared with the prior art, the embodiment of the application has the following advantages:
according to the method provided by the embodiment of the application, the first abstract syntax tree corresponding to the first source file is obtained firstly, then the first abstract syntax tree is modified to obtain the second abstract syntax tree, and finally the second abstract syntax tree is converted into the second source file.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings needed to be used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments described in the present application, and other drawings can be obtained by those skilled in the art without creative efforts.
FIG. 1 is a flowchart illustrating a method for obfuscating a code according to an embodiment of the present disclosure;
FIG. 2 is a schematic structural diagram of an obfuscating apparatus for code according to an embodiment of the present disclosure;
fig. 3 is an internal structural diagram of a computer device in the embodiment of the present application.
Detailed Description
In order to make the technical solutions of the present application better understood, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
The inventor finds that the existing method for obfuscating the code by using the middle layer of the LLVM compiler can only be converted into the machine instruction of the corresponding platform by the LLVM compiler, so that the obfuscated code cannot be transplanted and cannot be processed again by other compilers.
In order to solve the above problems, in the embodiment of the present application, based on the front end of the compiler, the expression in the abstract syntax tree is replaced with a more complex equivalent expression, that is, the original node in the abstract syntax tree is replaced with a new node, and finally, the result is converted into the source code, so that for both code protection and portability, the obfuscated code can still be compiled by various compilers and can also be transplanted to various platforms.
Various non-limiting embodiments of the present application are described in detail below with reference to the accompanying drawings.
The present application provides a method for obfuscating a code, as shown in fig. 1, the method including:
s1, acquiring a first Abstract Syntax Tree (AST) corresponding to the first source file.
Optionally, the first source file is C language source code or C + + source code. The compiler is an LLVM.
Specifically, in step S1, the compiler front end analyzes and processes the first source file to obtain the first abstract syntax tree corresponding to the first source file and a header file included in the first source file. For example: and analyzing and processing the C/C + + source file by utilizing a front end of the LLVM to obtain an abstract syntax tree corresponding to the source file and a header file contained in the first source file.
And S2, modifying the first abstract syntax tree to obtain a second abstract syntax tree.
For example, the following abstract syntax tree structure may be constructed
Is modified into
Specifically, step S2 includes:
and S21, traversing the nodes in the first abstract syntax tree.
And S22, judging whether the node is of the replaceable type.
Among the alternative types are: arithmetic operation expressions, bit operation expressions. The arithmetic operation expression may be addition, subtraction, multiplication, division, remainder, self-increment, self-decrement, etc., and the bit operation expression may be bit-and, bit-or, bit-not, bit-exclusive, left-shift, etc. For example: a + b may be replaced by a + (even &1) + b, even being a global variable with an even value.
For example: the following code segment can be used
Is replaced by
S23, if yes, replacing the node in the first abstract syntax tree with an equivalent expression; and if not, judging the next node until all the nodes in the abstract syntax tree are traversed.
Specifically, the traversal process is as follows: and judging whether each node in all the nodes of the abstract syntax tree is an arithmetic operation expression or a bit operation expression, if so, replacing the node with other more complex equivalent expressions, and if not, continuing to judge the next node. And when the judged node is the last node, finishing the traversal. The expression replacement is an obfuscation method, and the difficulty of cracking software is increased by replacing a simple expression with an equivalent complex expression.
Optionally, the method for replacing the node in the first abstract syntax tree with the equivalent expression is to remove the node of the original expression from the syntax tree and replace the node with the node of the new expression. The expression replacement is an obfuscation method, and by replacing equivalent more complex expressions with expressions, the difficulty of a cracker for cracking the program by using a static analysis tool is increased.
S3, converting the second abstract syntax tree into a second source file.
In this application, the second source file is an obfuscated source code, and the second source file can be compiled by various compilers and can also be transplanted to various platforms, that is, the obfuscated source code can still be compiled by various compilers and can also be transplanted to various platforms.
Specifically, step S3 includes:
s31, creating a blank source file, wherein the blank source file is the same as the first source file in type;
specifically, if the first source file is a C file, the blank source file is also a C file; if the first source file is a C + + file, the blank source file is also a C + + file.
S32, outputting a header file contained in the first source file to the blank source file according to a syntax form, and outputting a top-level statement in the second abstract syntax tree to the blank source file according to a syntax form to obtain the second source file.
Specifically, the top-level declaration is a declaration at the top level, which is not included in other declarations, such as definition of global variables in C language, definition of functions, definition of struct, definition of global variables in C + + language, definition of functions not in a namespace, definition of classes not in a namespace, and declaration of the outermost namespace (i.e., not embedded in another namespace). And outputting the top-level statement in the second abstract syntax tree to the blank source file according to a correct syntax form.
In the embodiment of the present application, the header file included in the first source file is output to the blank source file created in step S31 in the syntax form of a C/C + + header-containing file, and the top declaration in the abstract syntax tree is output to the blank source file created in step S31 in the correct syntax form as long as it is declared or defined in the original source file.
In an alternative embodiment of the present application, the obfuscation method of the code is: firstly, analyzing and processing a C/C + + source file by utilizing a front end clong of the LLVM to obtain an abstract syntax tree corresponding to the source file and a header file contained in a first source file; then, traversing all nodes in the abstract syntax tree, and if a certain node is an arithmetic operation expression or a bit operation expression, replacing the node with a more complex equivalent expression; then, creating a blank C or C + + file, wherein the blank source file is consistent with the original source file in type, namely if the source file is a C file, the blank source file is a C file, and if the source file is a C + + file, the blank source file is a C + + file); and finally, outputting the header file contained in the source file obtained in the step to the created blank source file according to the syntax form of the header file contained in the C/C + +, and simultaneously outputting the top-level statement in the abstract syntax tree to the created blank source file according to the correct syntax form of the top-level statement so as to complete the obfuscation of the code. The method and the device realize the replacement of the expression based on the front end of the compiler, and the obfuscated source code is output to realize the obfuscation of the source code, namely, the function of equivalent replacement of the expression of the C/C + + source code is realized at the front end part of the compiler, and the obfuscated C/C + + source code is output, so that the code protection capability and the portability are both realized.
The present application provides an apparatus for obfuscating a code, as shown in fig. 2, the apparatus including:
an obtaining unit 20, configured to obtain a first abstract syntax tree in a first source file;
a modifying unit 22, configured to modify the abstract syntax tree to obtain a second abstract syntax tree;
a converting unit 24, configured to convert the second abstract syntax tree into a second source file.
In an alternative embodiment, the modifying unit comprises: a traversing module for traversing nodes in the first abstract syntax tree; the judging module is used for judging whether the node is of a replaceable type; and the replacing module is used for replacing the nodes in the first abstract syntax tree with equivalent expressions if the judgment result is yes.
In an alternative embodiment, the conversion unit comprises: the creating module is used for creating a blank source file, and the blank source file is the same as the first source file in type; and the output module is used for outputting the second abstract syntax tree to the blank source file according to a syntax form to obtain the second source file, wherein the syntax form is a syntax form of a header file in the first source file.
In one embodiment, the present application provides a computer device, which may be a terminal, having an internal structure as shown in fig. 3. The computer device includes a processor, a memory, a network interface, a display screen, and an input device connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement a method of generating a natural language model. The display screen of the computer equipment can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, a key, a track ball or a touch pad arranged on the shell of the computer equipment, an external keyboard, a touch pad or a mouse and the like.
Those skilled in the art will appreciate that the illustration in fig. 3 is merely a block diagram of a portion of the structure associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.
An embodiment of the present application provides a computer device, including a memory and a processor, where the memory stores a computer program, and the processor implements the following steps when executing the computer program:
acquiring a first abstract syntax tree corresponding to a first source file;
modifying the first abstract syntax tree to obtain a second abstract syntax tree;
converting the second abstract syntax tree into a second source file.
An embodiment of the present application further provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the following steps:
acquiring a first abstract syntax tree corresponding to a first source file;
modifying the first abstract syntax tree to obtain a second abstract syntax tree;
converting the second abstract syntax tree into a second source file.
In summary, compared with the prior art, the embodiment of the present application has the following advantages:
according to the obfuscation method and device of the codes, the computer device and the storage medium, the method comprises the following steps: acquiring a first abstract syntax tree corresponding to a first source file; modifying the first abstract syntax tree to obtain a second abstract syntax tree; converting the second abstract syntax tree into a second source file. The method is used for obfuscating the codes, and the obfuscated codes can still be compiled by various compilers and can also be transplanted to various platforms.
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.
Claims (8)
1. A method of obfuscating code, the method comprising:
acquiring a first abstract syntax tree corresponding to a first source file;
modifying the first abstract syntax tree to obtain a second abstract syntax tree;
converting the second abstract syntax tree into a second source file;
the modifying the first abstract syntax tree to obtain a second abstract syntax tree includes:
traversing nodes in the first abstract syntax tree;
judging whether the node is of a replaceable type;
if so, replacing the nodes in the first abstract syntax tree by equivalent expressions;
if not, judging the next node until all the nodes in the abstract syntax tree are traversed; the traversal process comprises the following steps: judging whether each node in all nodes of the abstract syntax tree is an arithmetic operation expression or a bit operation expression, and if the node is the arithmetic operation expression, replacing the node with the equivalent expression; if the judgment result is negative, continuing to judge the next node; and when the judged node is the last node, finishing the traversal.
2. A method for obfuscating code according to claim 1, wherein obtaining a first abstract syntax tree corresponding to a first source file comprises:
and analyzing and processing the first source file by the front end of the compiler to obtain the first abstract syntax tree corresponding to the first source file and a header file contained in the first source file.
3. A method of obfuscation of code according to claim 1, wherein the alternative types include: arithmetic operation expressions, bit operation expressions.
4. A method for obfuscation of code according to claim 1, wherein converting the second abstract syntax tree into a second source file comprises:
creating a blank source file, the blank source file being of the same type as the first source file;
and outputting a header file contained in the first source file to the blank source file according to a syntactic form, and outputting a top-level statement in the second abstract syntactic tree to the blank source file according to a syntactic form to obtain the second source file.
5. A obfuscation method as in claim 2, wherein the compiler is an LLVM.
6. An apparatus for obfuscating code, the apparatus comprising:
the obtaining unit is used for obtaining a first abstract syntax tree in a first source file;
the modification unit is used for modifying the abstract syntax tree to obtain a second abstract syntax tree;
a conversion unit, configured to convert the second abstract syntax tree into a second source file;
the modification unit includes:
a traversing module for traversing nodes in the first abstract syntax tree;
the judging module is used for judging whether the node is of a replaceable type;
the replacing module is used for replacing the nodes in the first abstract syntax tree with equivalent expressions if the judgment result is yes; if not, judging the next node until all the nodes in the abstract syntax tree are traversed; the traversal process comprises the following steps: judging whether each node in all nodes of the abstract syntax tree is an arithmetic operation expression or a bit operation expression, and if the node is the arithmetic operation expression, replacing the node with the equivalent expression; if the judgment result is negative, continuing to judge the next node; and when the judged node is the last node, finishing the traversal.
7. A computer device comprising a memory and a processor, the memory storing a computer program, wherein the processor implements the steps of the method of any one of claims 1 to 5 when executing the computer program.
8. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method of any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910864925.3A CN110569628B (en) | 2019-09-09 | 2019-09-09 | Code obfuscation method and device, computer device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910864925.3A CN110569628B (en) | 2019-09-09 | 2019-09-09 | Code obfuscation method and device, computer device and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110569628A CN110569628A (en) | 2019-12-13 |
| CN110569628B true CN110569628B (en) | 2021-09-21 |
Family
ID=68779674
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910864925.3A Active CN110569628B (en) | 2019-09-09 | 2019-09-09 | Code obfuscation method and device, computer device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110569628B (en) |
Families Citing this family (6)
| 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 |
| CN112115428B (en) * | 2020-08-14 | 2024-04-09 | 咪咕文化科技有限公司 | Code file confusion method, device, electronic equipment and storage medium |
| CN113296783A (en) * | 2021-05-14 | 2021-08-24 | 北京奇艺世纪科技有限公司 | Code processing method and device, electronic equipment, storage medium and product |
| CN113641361B (en) * | 2021-06-28 | 2024-01-26 | 武汉极意网络科技有限公司 | Code hiding method and device based on Clang |
| CN113946804B (en) * | 2021-12-21 | 2022-05-20 | 深圳市活力天汇科技股份有限公司 | Source code obfuscation method and device |
| CN114417267A (en) * | 2022-01-24 | 2022-04-29 | 中国电信股份有限公司 | Code obfuscation method, device, electronic device and storage medium |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104142819A (en) * | 2013-07-10 | 2014-11-12 | 腾讯科技（深圳）有限公司 | File processing method and device |
| CN106415579A (en) * | 2014-03-31 | 2017-02-15 | 爱迪德技术有限公司 | Protecting an item of software |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105302842A (en) * | 2014-07-31 | 2016-02-03 | 北大方正集团有限公司 | Data processing method and device |
| CN109992785B (en) * | 2019-04-09 | 2023-07-25 | 腾讯科技（深圳）有限公司 | Content calculation method, device and equipment based on machine learning |
-
2019
- 2019-09-09 CN CN201910864925.3A patent/CN110569628B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104142819A (en) * | 2013-07-10 | 2014-11-12 | 腾讯科技（深圳）有限公司 | File processing method and device |
| CN106415579A (en) * | 2014-03-31 | 2017-02-15 | 爱迪德技术有限公司 | Protecting an item of software |
Non-Patent Citations (1)
| Title |
|---|
| 基于Clang的C++代码混淆工具设计与实现;张清泉;《中国优秀硕士学位论文全文数据库 信息科级辑》;中国学术期刊(光盘版)电子杂志社;20150415(第4期);第2,7-8,50-51页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110569628A (en) | 2019-12-13 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110569628B (en) | Code obfuscation method and device, computer device and storage medium | |
| CN110187885B (en) | Intermediate code generation method and device for quantum program compiling | |
| JP6490598B2 (en) | Compiler-based obfuscation | |
| US9530006B2 (en) | Method and system for performing a memory safety check of a program written in an unmanaged programming language | |
| US10269087B2 (en) | Language translation using preprocessor macros | |
| Dehesa-Azuara et al. | Verifying and synthesizing constant-resource implementations with types | |
| US8850414B2 (en) | Direct access of language metadata | |
| US10133560B2 (en) | Link time program optimization in presence of a linker script | |
| US9639335B2 (en) | Contextual typing | |
| JP4806060B2 (en) | Compiler program, compiling method, and computer system | |
| US10809985B2 (en) | Instrumenting program code | |
| CN110245467A (en) | Android application program guard method based on Dex2C and LLVM | |
| US20140372993A1 (en) | Overloading on constants | |
| Stiévenart et al. | Static stack-preserving intra-procedural slicing of webassembly binaries | |
| Gadelha et al. | SMT-based refutation of spurious bug reports in the clang static analyzer | |
| Kawaguchi et al. | Dsolve: Safety verification via liquid types | |
| Rahimian et al. | RESource: a framework for online matching of assembly with open source code | |
| CN113721928B (en) | Binary analysis-based dynamic library clipping method | |
| CN112270176B (en) | Method, apparatus, and computer storage medium for mode conversion in a deep learning framework | |
| US10642714B2 (en) | Mapping dynamic analysis data to source code | |
| US20030167462A1 (en) | Method and system for bidirectional bitwise constant propogation by abstract interpretation | |
| US9135027B1 (en) | Code generation and execution for dynamic programming languages | |
| CN111796832B (en) | Hot patch file generation method, device, equipment and storage medium | |
| WO2016189721A1 (en) | Source code evaluation device, source code evaluation method, and source code evaluation program | |
| Li et al. | Semantically find similar binary codes with mixed key instruction sequence |
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 |