CN114707124A - NET platform code protection method and system based on code virtualization - Google Patents
NET platform code protection method and system based on code virtualization Download PDFInfo
- Publication number
- CN114707124A CN114707124A CN202210284350.XA CN202210284350A CN114707124A CN 114707124 A CN114707124 A CN 114707124A CN 202210284350 A CN202210284350 A CN 202210284350A CN 114707124 A CN114707124 A CN 114707124A
- Authority
- CN
- China
- Prior art keywords
- msil
- code
- flow graph
- net platform
- control flow
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 68
- 238000005206 flow analysis Methods 0.000 claims description 12
- 238000010276 construction Methods 0.000 claims description 10
- 238000010586 diagram Methods 0.000 claims description 9
- 238000012795 verification Methods 0.000 claims description 5
- 238000004458 analytical method Methods 0.000 description 5
- 238000013475 authorization Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000000903 blocking effect Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000013519 translation 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
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/60—Protecting data
- G06F21/64—Protecting data integrity, e.g. using checksums, certificates or signatures
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Technology Law (AREA)
- Multimedia (AREA)
- Health & Medical Sciences (AREA)
- Bioethics (AREA)
- General Health & Medical Sciences (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention provides a NET platform code protection method based on code virtualization, which comprises the steps of constructing a control flow graph related to each process in a NET platform program, and constructing a data flow graph according to the control flow graph; according to the control flow graph and the data flow graph, the MSIL codes to be protected in the NET platform program are decompiled to obtain an MSIL syntax tree; compiling the MSIL syntax tree into a virtual intermediate language. The MSIL code to be protected in the NET platform program is converted into the virtual intermediate language which has the characteristics of customization, dynamicity and convertibility and is difficult to analyze, and various decompilers can be effectively prevented from converting the protected MSIL code into the high-level language, so that the key code of the NET platform program is not tampered and can be safely operated.
Description
Technical Field
The invention relates to the technical field of software security, in particular to a NET platform code protection method and system based on code virtualization.
Background
At present, many commercial software is often damaged by reverse engineering by an attacker, and core algorithms and confidential information in the software are stolen, so that the software copyright of many developers is damaged. Therefore, in many scenarios, the requirement for software code protection is increasing, for example, NET platforms, android applications, and some applications on devices of the internet of things all have security requirements on how to ensure that application code is not cracked reversely. All languages under the NET platform are based on Common Language Runtime (Common Language Runtime and standard following Common Language architecture, uniformly compiled into MSIL codes, and the MSIL codes after compiling are executed by the Common Language Runtime.
Currently, for the MSIL code protection scheme under the NET platform, a constant protection technology is mostly used, that is, a constant is encrypted, and the constant is decrypted in operation, or a control flow obfuscation technology is used, so that static analysis is disabled by obfuscating the execution sequence of the MSIL code. Although the method can increase the complexity of the MSIL code and is difficult to perform static analysis on the MSIL code, the internal execution flow of the program can still be known in a dynamic debugging mode, and the MSIL code information is further acquired.
Disclosure of Invention
The invention provides a NET platform code protection method and system based on code virtualization, aiming at solving the defect that a protected NET platform program code is easy to be reversely compiled into a high-level language.
In order to solve the technical problems, the technical scheme of the invention is as follows:
the invention provides a NET platform code protection method based on code virtualization, which comprises the following steps:
s1: constructing a control flow diagram of each process in a NET platform program, and constructing a data flow diagram according to the control flow diagram;
s2: according to the control flow graph and the data flow graph, the MSIL codes to be protected in the NET platform program are decompiled to obtain an MSIL syntax tree;
s3: compiling the MSIL syntax tree into a virtual intermediate language.
Preferably, S1 specifically includes the following steps:
s1.1: analyzing metadata of a NET platform program, acquiring a method body needing virtualization in the NET platform program, and extracting MSIL codes and exception handling clauses of the method body;
s1.2: decoding the instruction of the MSIL code, and distributing stack elements in an MSIL code stack to local variables;
s1.3: constructing a control flow graph according to the jump instruction and the exception handling clause of the MSIL code;
s1.4: and carrying out data flow analysis on the NET platform program based on the control flow graph and the local variable to construct a data flow graph.
Preferably, S1.2 specifically comprises the following steps:
s1.2.1: traversing each instruction of the MSIL code backwards according to the offset sequence from the head part of the MSIL code, and storing stack information before execution for each instruction;
s1.2.2: and according to the stack information, allocating each stack element in the MSIL code stack to a local variable, and allocating names to the local variables according to the stack sequence.
Preferably, in S1.2.2, when each stack element in the stack of the MSIL code is assigned to a local variable, by fusing information of an entry node of the program, if the entry node has a local variable of a 64-bit integer type, the local variable of the 32-bit integer type is converted into the local variable of the 64-bit integer type; if the in-node of the dataflow graph is a reference type, then the local variable is set to the base class Object type.
As a preferred scheme, in S1.3, a basic block of the control flow graph is divided by using a jump instruction of the MSIL code and an exception handling clause as boundaries, and a jump source and a jump target of the jump instruction are respectively set as a predecessor node and a successor node of the control flow graph, so as to obtain the control flow graph.
As a preferred scheme, the method further comprises a verification operation on the method body, the MSIL code of the method body and the exception handling clause, and specifically comprises the following steps:
verifying the support states of all operation codes in the body of the method;
verifying the stack balance state of the MSIL code;
and verifying the sequential arrangement state of the exception handling clauses.
As a preferred scheme, in S1.4, the performing data flow analysis on the NET platform program includes analyzing local variables;
if the local variable has an address fetching operation, generating a virtual reference type for the local variable; if the pointer obtained after the address fetch operation of the local variable is executed with the mathematical operation, an error is thrown when the local variable is allocated.
Preferably, in S3, the MSIL syntax tree is compiled into a virtual intermediate language-based syntax tree, and then the virtual intermediate language-based syntax tree is compiled into a virtual intermediate language.
Preferably, the virtualization protection method further includes: compiling the MSIL syntax tree into a virtual intermediate language, and converting the virtual intermediate language into a serializable form; saving the serializable virtual intermediate language as a hexadecimal array to be written into a file.
In a second aspect, the present invention further provides a NET platform code virtualization protection system, which is applied to any one of the above solutions, where the NET platform code protection method based on code virtualization includes:
the NET platform program comprises a control flow graph construction module, a network flow graph generation module and a network flow graph generation module, wherein the control flow graph construction module is used for constructing a control flow graph of each process in a NET platform program;
the data flow graph building module is used for building a data flow graph according to the control flow graph;
the decompiling module is used for decompiling MSIL codes to be protected in the NET platform program according to the control flow graph and the data flow graph to obtain an MSIL syntax tree;
and the compiling module is used for compiling the MSIL grammar tree into a virtual intermediate language.
Compared with the prior art, the technical scheme of the invention has the beneficial effects that: the method has the advantages that the MSIL codes to be protected in the NET platform program are converted into the virtual intermediate language which has self-definition, dynamic and convertibility and is difficult to analyze, and various decompilers can be effectively prevented from converting the protected MSIL codes into the high-level language, so that the key codes of the NET platform program are not tampered, and the safe operation can be realized.
Drawings
Fig. 1 is a flowchart of a NET platform code protection method based on code virtualization in embodiment 1.
Fig. 2 is a flowchart of the runtime for implementing the virtual intermediate language in embodiment 3.
Fig. 3 is an architecture diagram of the NET platform code virtualization protection system in embodiment 4.
Detailed Description
The drawings are for illustrative purposes only and are not to be construed as limiting the patent;
the technical solution of the present invention is further described below with reference to the accompanying drawings and examples.
Example 1
This embodiment proposes a network platform code protection method based on code virtualization, as shown in fig. 1, where fig. 1 is a flowchart of the network platform code protection method based on code virtualization in this embodiment, and the method includes the following steps:
s1: a control flow graph related to each process in a NET platform program is built, and a data flow graph is built according to the control flow graph.
S2: and according to the control flow graph and the data flow graph, decompiling MSIL codes to be protected in the NET platform program to obtain an MSIL syntax tree.
S3: compiling the MSIL syntax tree into a virtual intermediate language.
In the specific implementation process, each process in the NET platform program is analyzed to determine the execution process of the NET platform program, so that a control flow graph is obtained, and the data flow analysis is performed on the basis of the control flow graph, so that a data flow graph is obtained. According to the control flow graph and the data flow graph, the MSIL code to be protected in the NET platform program based on the stack is decompiled, and the MSIL code is converted into a form based on local variables to obtain an MSIL syntax tree. The MSIL syntax tree has the same semantics as the MISL code, is not dependent on the stack, has an expression form similar to a high-level language, and has the advantage of being more convenient to analyze compared with the MSIL code. And finally, compiling the MSIL syntax tree into a syntax tree based on a virtual intermediate language, and then compiling the syntax tree based on the virtual intermediate language into the virtual intermediate language, so that the virtual intermediate language safely runs on the running of the virtual language.
The method has the advantages that the MSIL codes to be protected in the NET platform program are converted into the virtual intermediate language which has customizability, dynamic property and convertibility and is difficult to analyze, and various decompilers can be effectively prevented from converting the protected MSIL codes into the high-level language, so that the key codes of the NET platform program are not tampered, can safely run on the virtual language running, and is suitable for protecting the key codes of the program, such as codes for verification authorization and the like.
Example 2
The embodiment provides a NET platform code protection method based on code virtualization, which comprises the following steps:
s1: a control flow graph related to each process in a NET platform program is built, and a data flow graph is built according to the control flow graph. The method specifically comprises the following steps:
s1.1: analyzing the metadata of the NET platform program, acquiring a method body needing virtualization in the NET platform program, and extracting the MSIL code and the exception handling clause of the method body.
In this embodiment, the method body to be virtualized is marked and acquired through the protection parameters transmitted by the user.
In this embodiment, the verification operation of the method body, the MSIL code of the method body, and the exception handling clause specifically includes the following steps:
and verifying the support state of all operation codes in the method body and ensuring that all operation codes in the method body are supported. If there is an unsupported opcode in the method body, an exception is thrown.
Verifying stack balance state of MSIL code, determining whether stack of MSIL code is balanced, and preventing incorrect MSIL code from entering into subsequent processing. If the MSIL code stack is not balanced, an exception is thrown.
And verifying the sequential arrangement state of the exception handling clauses, and determining whether the exception handling clauses are arranged in sequence or not to ensure the correctness of the language. If the exception handling clause arrangement is invalid, an exception is thrown.
S1.2: decoding the instructions of the MSIL code, and distributing stack elements in the MSIL code stack to local variables. The method specifically comprises the following steps:
s1.2.1: traversing each instruction of the MSIL code backwards according to the offset sequence from the head part of the MSIL code, and storing stack information before execution for each instruction;
s1.2.2: and according to the stack information, each stack element in the stack of the MSIL codes is distributed to a local variable, and names are distributed to the local variables according to the stack sequence. Stack elements in a stack of the MSIL codes are converted into local variables, so that the MSIL codes are converted from a stack-based architecture into a local variable-based architecture, and subsequent debugging is facilitated.
In this embodiment, when each stack element in the stack of the MSIL code is assigned to a local variable, a compatible local variable type needs to be obtained by fusing information of all the ingress nodes.
For a local variable of the 32-bit integer type, it needs to be converted into a local variable of the native-size integer type or a local variable of the 64-bit integer type to satisfy the allocation of the in-node value. For reference type local variables, unified translation to base class Object local variables does not require computation of a common base class, since all reference types are pointers to a GC (Garbage Collection) heap at runtime, equal in size to native integers. Through the conversion processing, an intermediate code form based on variables can be obtained, and the analysis is more convenient and efficient than the original intermediate code based on a stack.
S1.3: and constructing a control flow graph according to the jump instruction of the MSIL code and the exception handling clause.
In this embodiment, the basic block of the control flow graph is divided by using the jump instruction of the MSIL code and the exception handling clause as boundaries, and the jump source and the jump target of the jump instruction are respectively set as a predecessor node and a successor node of the control flow graph, so as to obtain the control flow graph. The jump instruction is a branch statement of the MSIL code.
S1.4: and carrying out data flow analysis on the NET platform program based on the control flow graph and the local variable to construct a data flow graph.
In this embodiment, on the basis of the control flow graph, data flow analysis is performed in combination with stack local variable information, which indicates where the local variable is assigned, valued, and addressed. Data flow analysis is the analysis of data flows in a control flow graph, i.e., the analysis to determine information about the definition and use of data in a program. The propagation process of the variable values can be derived using data flow analysis whose results represent information available for compilation and optimization, indicating the flow of data when the program is executing, which can be used to compile the MSIL code into a virtual intermediate language.
S2: according to the control flow graph and the data flow graph, the MSIL codes to be protected in the NET platform program are decompiled to obtain an MSIL syntax tree;
s3: compiling the MSIL syntax tree into a virtual intermediate language.
In this embodiment, after the MSIL syntax tree is compiled into a virtual intermediate language, the virtual intermediate language is converted into a serializable form; the serializable virtual intermediate language is stored as a hexadecimal array and written into a file for executing the virtual machine, and the running of the virtual intermediate language is realized.
In this embodiment, in the process of compiling the MSIL syntax tree into the virtual intermediate language, when an unsupported MSIL syntax node is encountered, the exception blocking is selected to be thrown out, and the compilation is continued. Since the virtual intermediate language is executed by a virtual machine written in a secure managed language, there are partially non-simulatable operations, such as operations referenced to the GC heap, while such operations are identical to pointer operations at the MSIL language level. To avoid data corruption, data flow analysis is required to obtain where variables are valued and amplitude, and where variables are addressed.
If the local variable has an address fetching operation, generating a virtual reference type for the local variable, wherein the virtual reference type abstracts all pointer operations but cannot acquire an original address of a pointer; if the pointer obtained after the address fetching operation of the local variable is executed with mathematical operation, the mathematical operation will be invalid because the virtual reference type cannot obtain the original address of the pointer, i.e. such MSIL language cannot be compiled to the virtual intermediate language, and an error needs to be thrown when the variable is allocated.
Example 3
The present embodiment is an improvement on the NET platform code protection method based on code virtualization proposed in embodiment 2, and includes using a virtual intermediate language for execution of a virtual machine, and implementing runtime of the virtual intermediate language, as shown in fig. 2, where fig. 2 is a flowchart of implementing runtime of the virtual intermediate language in the present embodiment, and specifically includes the following steps:
the virtual runtime executes initialization operation at the program entry point, initializes variables required by the virtual runtime, loads execution interfaces of all virtual operation codes, and maps the original values of the virtual operation codes and the execution interfaces into a dictionary.
Analyzing parameters transmitted by the method entry stub to obtain the position of the virtual intermediate language, loading the virtual intermediate language into the virtual machine, and creating a virtual execution context.
And calling a corresponding execution interface for the current virtual operation code, setting the position of the next virtual instruction, and repeating the steps until the method is finished. And if the exception occurs in the execution, simulating stack backtracking, judging whether the exception can be captured, if the exception can be captured, executing an exception handling clause, otherwise throwing the exception, and exiting the virtual machine.
Example 4
The embodiment provides a NET platform code virtualization protection system, as shown in FIG. 3, where FIG. 3 is an architecture diagram of the NET platform code virtualization protection system, and the architecture diagram includes a control flow graph construction module, a data flow graph construction module, a decompilation module, and a compilation module.
In a specific implementation process, a control flow graph construction module constructs a control flow graph related to each process in a NET platform program, and a data flow graph construction module constructs a data flow graph according to the control flow graph, and specifically comprises the following steps:
and the control flow graph construction module analyzes the metadata of the NET platform program, acquires a method body needing virtualization in the NET platform program, and extracts the MSIL code and the exception handling clause of the method body. Decoding the instruction of the MSIL code, and distributing the stack elements in the stack of the MSIL code to local variables. And constructing a control flow graph according to the jump instruction of the MSIL code and the exception handling clause.
And the data flow graph construction module is used for carrying out data flow analysis on the NET platform program based on the control flow graph and the local variable to construct a data flow graph. In this embodiment, on the basis of the control flow graph, data flow analysis is performed in combination with stack local variable information, which indicates where the local variable is assigned, valued, and addressed.
And the decompiling module is used for decompiling MSIL codes to be protected in the NET platform program according to the control flow graph and the data flow graph, and converting the MSIL codes into a form based on local variables to obtain an MSIL syntax tree.
The compiling module compiles the MSIL syntax tree into a virtual intermediate language-based syntax tree, and then compiles the virtual intermediate language-based syntax tree into a virtual intermediate language.
The method has the advantages that the MSIL codes to be protected in the NET platform program are converted into the virtual intermediate language which has customizability, dynamic property and convertibility and is difficult to analyze, and various decompilers can be effectively prevented from converting the protected MSIL codes into the high-level language, so that the key codes of the NET platform program are not tampered, can safely run on the virtual language running, and is suitable for protecting the key codes of the program, such as codes for verification authorization and the like.
The terms describing positional relationships in the drawings are for illustrative purposes only and are not to be construed as limiting the patent;
it should be understood that the above-described embodiments of the present invention are merely examples for clearly illustrating the present invention, and are not intended to limit the embodiments of the present invention. Other variations and modifications will be apparent to persons skilled in the art in light of the above description. And are neither required nor exhaustive of all embodiments. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the claims of the present invention.
Claims (10)
1. NET platform code protection method based on code virtualization is characterized by comprising the following steps:
s1: constructing a control flow diagram of each process in a NET platform program, and constructing a data flow diagram according to the control flow diagram;
s2: according to the control flow graph and the data flow graph, the MSIL codes to be protected in the NET platform program are decompiled and converted into a form based on local variables, and an MSIL syntax tree is obtained;
s3: compiling the MSIL syntax tree into a virtual intermediate language.
2. The method of claim 1, wherein the step of S1 comprises the following steps:
s1.1: analyzing metadata of a NET platform program, acquiring a method body needing virtualization in the NET platform program, and extracting MSIL codes and exception handling clauses of the method body;
s1.2: decoding the instruction of the MSIL code, and distributing stack elements in the MSIL code stack to local variables;
s1.3: constructing a control flow graph according to the jump instruction and the exception handling clause of the MSIL code;
s1.4: and carrying out data flow analysis on the NET platform program based on the control flow graph and the local variable to construct a data flow graph.
3. The code virtualization-based NET platform code protection method of claim 2, wherein S1.2 specifically comprises the steps of:
s1.2.1: traversing each instruction of the MSIL code backwards according to the offset sequence from the head part of the MSIL code, and storing stack information before execution for each instruction;
s1.2.2: and according to the stack information, allocating each stack element in the MSIL code stack to a local variable, and allocating names to the local variables according to the stack sequence.
4. NET platform code protection method based on code virtualization according to claim 3, characterized in that in S1.2.2, when each stack element in the stack of MSIL code is assigned to a local variable, if the local variable of 64-bit integer type exists in the ingress node, the local variable of 32-bit integer type is converted into the local variable of 64-bit integer type by fusing the information of the ingress node of the program; if the in-node of the dataflow graph is a reference type, then the local variable is set to the base class Object type.
5. NET platform code protection method according to claim 2, characterized in that in S1.3, the jump instruction and exception handling clause of MSIL code are taken as boundaries to divide basic blocks of the control flow graph, and the jump source and the jump target of the jump instruction are respectively set as a predecessor node and a successor node of the control flow graph to obtain the control flow graph.
6. The code virtualization-based NET platform code protection method of claim 2, wherein in S1.1, further comprising a verification operation on the MSIL code and exception handling clauses of the method body and the method body, the method specifically comprises the following steps:
verifying the support states of all operation codes in the body of the method;
verifying the stack balance state of the MSIL code;
and verifying the sequential arrangement state of the exception handling clauses.
7. The method of claim 2, wherein the data flow analysis of the NET platform program includes analyzing local variables;
if the local variable has an address fetching operation, generating a virtual reference type for the local variable; if the pointer obtained after the address fetching operation of the local variable is executed with the mathematical operation, an error is thrown when the local variable is distributed.
8. NET platform code protection method based on code virtualization according to claim 1, characterized in that in S3 the MSIL syntax tree is compiled into a virtual intermediate language based syntax tree, which is then compiled into a virtual intermediate language.
9. The method of claim 1, wherein the method further comprises: after the MSIL syntax tree is compiled into a virtual intermediate language, the virtual intermediate language is converted into a serializable form; saving the serializable virtual intermediate language as a hexadecimal array to be written into a file.
NET platform code virtualization protection system, characterized by comprising:
the NET platform program comprises a control flow graph construction module, a network flow graph generation module and a network flow graph generation module, wherein the control flow graph construction module is used for constructing a control flow graph of each process in a NET platform program;
the data flow graph building module is used for building a data flow graph according to the control flow graph;
the decompiling module is used for decompiling MSIL codes to be protected in the NET platform program according to the control flow graph and the data flow graph to obtain an MSIL syntax tree;
and the compiling module is used for compiling the MSIL grammar tree into a virtual intermediate language.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210284350.XA CN114707124B (en) | 2022-03-22 | 2022-03-22 | NET platform code protection method and system based on code virtualization |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210284350.XA CN114707124B (en) | 2022-03-22 | 2022-03-22 | NET platform code protection method and system based on code virtualization |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114707124A true CN114707124A (en) | 2022-07-05 |
| CN114707124B CN114707124B (en) | 2022-11-29 |
Family
ID=82168612
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210284350.XA Active CN114707124B (en) | 2022-03-22 | 2022-03-22 | NET platform code protection method and system based on code virtualization |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114707124B (en) |
Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20050015753A1 (en) * | 2003-07-18 | 2005-01-20 | Erik Meijer | Virtual method protection |
| CN101216775A (en) * | 2008-01-03 | 2008-07-09 | 北京深思洛克数据保护中心 | Software program protection method, device and system |
| US20090138863A1 (en) * | 2007-11-22 | 2009-05-28 | Feitian Technologies Co., Ltd. | Method And Apparatus For Protecting .NET Programs |
| CN101529436A (en) * | 2006-10-27 | 2009-09-09 | 微软公司 | Virtualization for diversified tamper resistance |
| CN106096338A (en) * | 2016-06-07 | 2016-11-09 | 西北大学 | A kind of have the virtualization software guard method that data stream is obscured |
| CN107292131A (en) * | 2017-06-21 | 2017-10-24 | 北京深思数盾科技股份有限公司 | Method for protecting software and device |
| CN108345773A (en) * | 2017-07-27 | 2018-07-31 | 江苏通付盾信息安全技术有限公司 | Code protection method and device, electronic equipment, storage medium based on virtual machine |
| CN112114933A (en) * | 2020-08-14 | 2020-12-22 | 咪咕文化科技有限公司 | Application program protection method, electronic device and storage medium |
| CN113626773A (en) * | 2020-05-06 | 2021-11-09 | 上海蜚语信息科技有限公司 | Code protection method based on intermediate language |
-
2022
- 2022-03-22 CN CN202210284350.XA patent/CN114707124B/en active Active
Patent Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20050015753A1 (en) * | 2003-07-18 | 2005-01-20 | Erik Meijer | Virtual method protection |
| CN101529436A (en) * | 2006-10-27 | 2009-09-09 | 微软公司 | Virtualization for diversified tamper resistance |
| US20090138863A1 (en) * | 2007-11-22 | 2009-05-28 | Feitian Technologies Co., Ltd. | Method And Apparatus For Protecting .NET Programs |
| CN101216775A (en) * | 2008-01-03 | 2008-07-09 | 北京深思洛克数据保护中心 | Software program protection method, device and system |
| CN106096338A (en) * | 2016-06-07 | 2016-11-09 | 西北大学 | A kind of have the virtualization software guard method that data stream is obscured |
| CN107292131A (en) * | 2017-06-21 | 2017-10-24 | 北京深思数盾科技股份有限公司 | Method for protecting software and device |
| CN108345773A (en) * | 2017-07-27 | 2018-07-31 | 江苏通付盾信息安全技术有限公司 | Code protection method and device, electronic equipment, storage medium based on virtual machine |
| CN113626773A (en) * | 2020-05-06 | 2021-11-09 | 上海蜚语信息科技有限公司 | Code protection method based on intermediate language |
| CN112114933A (en) * | 2020-08-14 | 2020-12-22 | 咪咕文化科技有限公司 | Application program protection method, electronic device and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114707124B (en) | 2022-11-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Nanda et al. | BIRD: Binary interpretation using runtime disassembly | |
| CN108681457B (en) | Android application program protection method based on code sinking and residual code interpretation | |
| Zhao et al. | Formalizing the LLVM intermediate representation for verified program transformations | |
| EP1258805B1 (en) | Placing exception throwing instruction in compiled code | |
| Myreen | Verified just-in-time compiler on x86 | |
| US8090959B2 (en) | Method and apparatus for protecting .net programs | |
| CN110245467B (en) | Android application program protection method based on Dex2C and LLVM | |
| US9524175B2 (en) | Target typing of overloaded method and constructor arguments | |
| Hasabnis et al. | Extracting instruction semantics via symbolic execution of code generators | |
| Zhao et al. | Compile-time code virtualization for android applications | |
| Cifuentes et al. | Experience in the design, implementation and use of a retargetable static binary translation framework | |
| Casset | Development of an embedded verifier for java card byte code using formal methods | |
| Liu et al. | Exploring missed optimizations in webassembly optimizers | |
| Larmuseau et al. | A secure compiler for ML modules | |
| Biggar et al. | A practical solution for scripting language compilers | |
| CN114115884B (en) | Method and related device for managing programming service | |
| CN100468437C (en) | .Net program protection method and system | |
| Ferrara et al. | CIL to Java-bytecode translation for static analysis leveraging | |
| Kwon et al. | Assessment of the Java programming language for use in high integrity systems | |
| CN114707124B (en) | NET platform code protection method and system based on code virtualization | |
| Chang et al. | Analysis of low-level code using cooperating decompilers | |
| Lee et al. | Debugging mixed‐environment programs with Blink | |
| Pauley et al. | Performant binary fuzzing without source code using static instrumentation | |
| Verbeek et al. | Highly Automated Formal Proofs over Memory Usage of Assembly Code | |
| Wen et al. | WasmAndroid: a cross-platform runtime for native programming languages on Android (WIP paper) |
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 |