CN110598379A - Method, system, equipment and storage medium for implementing character string confusion - Google Patents
Method, system, equipment and storage medium for implementing character string confusion Download PDFInfo
- Publication number
- CN110598379A CN110598379A CN201910897726.2A CN201910897726A CN110598379A CN 110598379 A CN110598379 A CN 110598379A CN 201910897726 A CN201910897726 A CN 201910897726A CN 110598379 A CN110598379 A CN 110598379A
- Authority
- CN
- China
- Prior art keywords
- syntax tree
- character string
- character
- array
- file
- 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 44
- 238000012545 processing Methods 0.000 claims abstract description 14
- 230000006870 function Effects 0.000 claims description 39
- 230000004048 modification Effects 0.000 claims description 23
- 238000012986 modification Methods 0.000 claims description 23
- 230000003068 static effect Effects 0.000 claims description 17
- 230000008569 process Effects 0.000 claims description 5
- 238000004891 communication Methods 0.000 description 5
- 238000004590 computer program Methods 0.000 description 3
- 238000010586 diagram Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 230000008859 change Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000006872 improvement Effects 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
- 238000002054 transplantation Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/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/602—Providing cryptographic facilities or services
-
- 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
-
- 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
Abstract
The invention provides a method, a system, equipment and a storage medium for realizing character string confusion, wherein the method comprises the following steps: analyzing and processing the source file to obtain a syntax tree corresponding to the source file and a header file contained in the syntax tree; encrypting and modifying the syntax tree to encrypt the character string constant, operating, decrypting and modifying the syntax tree to decrypt and restore the character string constant when the program operates; and outputting the encrypted source code by the front end of the compiler according to the modified syntax tree. The method realizes the confusion of the character strings at the front end of the compiler, and can obtain the C/C + + source code according to the output of the modified syntax tree, so that the C/C + + source code can be compiled by various compilers and can be transplanted to various platforms, and the safety and the portability of the program are considered.
Description
Technical Field
The present invention relates to the field of communication security technologies, and in particular, to a method, a system, a device, and a storage medium for implementing string confusion.
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. String constants, usually a hint or other meaningful information, can be quickly located to key points of program functions during reverse analysis to find breakthrough, and string obfuscation is an obfuscation method that can hide string constants so that they cannot be directly observed in the final binary program file. For example, in image processing application software programming, mobile information security needs to be implemented to prevent malicious reverse analysis.
OLLVM (Obfuscator-LLVM) is an open source project, and aims to provide a set of open source code obfuscation tools for LLVM (Low Level Virtual machine) so as to increase the difficulty of reverse engineering. At present, the C/C + + obfuscation technology is implemented based on the OLLVM, obfuscated codes in the intermediate layer representation form are all obfuscated, and obfuscated results can only be converted into machine instructions of a corresponding platform by the LLVM compiler, cannot be transplanted, and cannot be processed again by other compilers.
Accordingly, the prior art is in need of improvement and development.
Disclosure of Invention
In view of the above deficiencies of the prior art, the present invention provides a method, a system, a device and a storage medium for implementing string obfuscation, which aim to solve the problem that in the prior art, an OLLVM obfuscation middle layer representation form code can only be converted into a machine instruction by an LLVM compiler, and cannot be transplanted and cannot be processed again by other compilers.
In order to solve the above problems, the present invention discloses a method for implementing character string confusion, which is applied to a compiler front end, and the method comprises the following steps:
analyzing and processing the source file to obtain a syntax tree corresponding to the source file and a header file contained in the syntax tree;
modifying the syntax tree at the front end of the compiler;
the obfuscated source code is output by the compiler front-end according to the modified syntax tree.
Further, the step of modifying the syntax tree at the front end of the compiler specifically includes:
encrypting and modifying the syntax tree to encrypt the character string constant;
and (4) carrying out operation decryption modification on the syntax tree to ensure that the character string constant is decrypted and restored when the program operates.
Further, the step of encrypting and modifying the syntax tree to encrypt the string constant specifically includes:
a first character array and a second character array are inserted in the syntax tree.
Further, the step of inserting the first character array and the second character array in the syntax tree specifically includes:
traversing the syntax tree, collecting all character string constants in the syntax tree and recording the sequence of the character string constants;
encrypting the collected string constants by using a key;
inserting a first character array, wherein the first character array stores encrypted character string constants; and inserting a second character array, wherein the second character array stores a secret key.
Further, the decrypting and modifying the syntax tree so that the decrypting and restoring step of the character string constant when the program runs specifically includes:
inserting a static global pointer array into the syntax tree;
inserting a decryption function, wherein the decryption function decrypts and restores the first character array when the program runs;
inserting a GetString function, wherein the GetString function returns a decrypted character string constant specified by the parameter of the GetString function;
and traversing the modified syntax tree, and replacing the character string constant in the syntax tree with the call of the GetString function.
Further, the step of outputting the obfuscated source code by the syntax tree modified by the compiler front end specifically includes:
creating a blank file, wherein the type of the blank file is consistent with that of the source file;
outputting a header file contained in the source file to the blank file in a correct syntax form;
and outputting the top-level declaration in the syntax tree to the blank file in a correct syntax form.
Further, the operation decryption modification of the syntax tree so that the process of decrypting and restoring the constant of the character string when the program operates comprises:
when the program runs, the decryption function decrypts the encrypted first character array;
storing the address of the first character of each character string constant in the decrypted first character array in a static global pointer array;
and the GetString function returns a corresponding character string pointer in the static global pointer array according to the sequence of the replaced character string constant, and the character string pointer points to the character string in the decrypted first character array, so that the GetString function calls to obtain a corresponding original character string.
Correspondingly, in order to ensure the implementation of the method, the invention also provides a system for implementing character string confusion based on the front end of the compiler, and the system comprises:
the code compiling module is used for analyzing and processing the source file to obtain a grammar tree corresponding to the source file and a header file contained in the grammar tree;
the encryption modification module is used for carrying out encryption modification on the syntax tree so as to carry out encryption;
the decryption modification module is used for carrying out operation decryption modification on the syntax tree so as to decrypt and restore the character string constant when the program operates;
a code output module for outputting the obfuscated source code at a compiler front-end according to the modified syntax tree.
A device for implementing character string confusion based on a compiler front end:
the device comprises a processor and a memory connected with the processor; the memorizer stores a program for realizing character string confusion based on the front end of the compiler, and the method for realizing the character string confusion based on the front end of the compiler is realized when the program for realizing the character string confusion based on the front end of the compiler is executed by the processor.
A storage medium in which a program for implementing the method of implementing character string obfuscation as described above is stored.
Has the advantages that: compared with the prior art, the invention provides a method, a system, equipment and a storage medium for realizing character string confusion, wherein the method comprises the following steps: analyzing and processing the source file to obtain a syntax tree corresponding to the source file and a header file contained in the syntax tree; modifying the syntax tree at the front end of the compiler; the obfuscated source code is output by the compiler front-end according to the modified syntax tree. According to the method, the syntax tree is subjected to obfuscation processing at the front end of the compiler, malicious reverse analysis of the code is avoided, the C/C + + source code can be obtained after obfuscation, the problems that a specified compiler is converted into a machine instruction based on middle-layer obfuscated code intelligence at present, transplantation cannot be carried out, and processing cannot be carried out by other compilers are effectively solved, so that the code has safety and portability, and convenience is brought to program development.
Drawings
FIG. 1 is a flowchart of an embodiment of a method for implementing string obfuscation based on a compiler front-end according to the present invention.
FIG. 2 is a flowchart illustrating a method for implementing string obfuscation based on a compiler front end according to an embodiment of the present invention.
FIG. 3 is a block diagram of an embodiment of a system for implementing string obfuscation based on a compiler front-end according to the present invention.
FIG. 4 is a block diagram of an embodiment of an apparatus for implementing string obfuscation based on a compiler front-end according to the present invention.
In the figure, 10, a code compiling module; 20. an encryption modification module; 30. a decryption modification module; 40. a code output module; 50. a processor; 51. a display screen; 52. a memory; 53. a communication interface; 54. a bus.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, 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 invention.
As shown in fig. 1 and fig. 2, an embodiment of the present invention provides a method for implementing string obfuscation, which is applied to a compiler front end, and the method may also be used in fields including, but not limited to, application software programming of image processing. In this embodiment, the following source code is taken as an example to illustrate the processing procedure, and the code is as follows:
one embodiment of the present invention provides a method for implementing character string confusion, which includes the steps of:
step S100, analyzing and processing the source file to obtain a syntax tree corresponding to the source file and a header file contained in the syntax tree.
Specifically, llvm (low Level Virtual machine) engineering is a collection of compiler and toolchain techniques that are reusable modules. The sub-project Clang provides a foundation for compiling tools requiring semantic analysis and grammar analysis. Lexical analysis and semantic analysis can be performed on the source file by using the Clang project to obtain a syntax tree and a header file corresponding to the source file. The source file refers to source code written by a developer in advance, the syntax tree refers to an abstract syntax tree, and the abstract syntax tree is an abstract representation of a syntax structure of the source code. It represents the syntactic structure of the programming language in the form of a tree, each node on the tree representing a structure in the source code.
And S200, encrypting and modifying the syntax tree to encrypt the character string constant.
Specifically, the syntax tree is encrypted and modified at the front end of the compiler, so that the character string constant is encrypted. In a preferred embodiment, step S200 specifically includes:
step S210, traversing the abstract syntax tree, collecting all the character string constants in the abstract syntax tree, and recording the sequence of each character string constant;
specifically, after a source file is processed, an abstract syntax tree is obtained, traversal operation is performed on the abstract syntax tree, all nodes in the abstract syntax tree are traversed, character string constants in all the nodes in the abstract syntax tree are obtained, and each character string constant is recorded as a collected character string constant.
Step S220, sequentially putting the collected character string constants into a first temporary character array;
specifically, a first temporary character array is created, the collected character string constants are sequentially placed into the first temporary character array according to the collection sequence, and the end character NUL of each character string is also stored. Repeated string constants are not stored in the first temporary character array, namely the string constants appearing again are directly skipped over and are not placed in the first temporary character array, so that the space is saved, and the operation amount of encryption and decryption is reduced.
Step S230, randomly generating a key, and storing the key in a second temporary character array;
specifically, a key is randomly generated, a second temporary character array is created, and the key is stored in the second temporary character array.
Step S240, encrypting the first temporary character array by using the key;
specifically, the encryption algorithm uses the key in the second temporary character array to encrypt the character string constant in the first temporary character array, so that the character string constant in the first temporary character array is changed and cannot be directly observed. It is easily conceivable that the key may be generated randomly or may be set in advance.
Step S250, inserting a first character array, wherein the first character array stores encrypted character string constants; inserting a second character array, wherein a secret key is stored in the second character array;
specifically, a first character array and a second character array are inserted into corresponding positions of the abstract syntax tree. After the first temporary character array is encrypted by the key, the character string constant in the first temporary character array is changed, the content in the encrypted first temporary character array is put into the first character array, and the content in the second temporary character array is put into the second character array.
And step S300, carrying out operation decryption modification on the syntax tree to decrypt and restore the character string constant when the program operates.
Specifically, the abstract syntax tree is modified at the front end of the compiler, so that the constant of the character string can be restored when the program runs, and normal running is guaranteed.
In a preferred embodiment, step S300 includes:
step S310, inserting a static global pointer array into the abstract syntax tree;
specifically, when the front end of the compiler modifies the syntax tree, a static global pointer array is also inserted into the syntax tree. The type of the static global pointer array is char [ ], and the number of elements of the static global pointer array is the same as the number of collected string constants.
Step S320, inserting a decryption function, wherein the decryption function decrypts and restores the first character array when the program runs, and places the address of the first character of each decrypted character string constant into a static global pointer array;
specifically, when the front end of the compiler modifies the syntax tree, a decryption function is also inserted. And when the program runs, the decryption function decrypts the character string constant in the first character array and restores the encrypted character string constant into the originally collected character string constant. The decryption function refers to an algorithm function which can perform algorithm decryption on the encrypted character string in the first character array by using the key to obtain the original corresponding character string constant, the decryption algorithm of the decryption function corresponds to the encryption algorithm of the encryption function, and the encrypted character string constant can be restored through the key. After the key decrypts the encrypted string constants, the addresses of the first characters of the decrypted string constants are placed in a static global pointer array.
And step S330, inserting a GetString function into the syntax tree, traversing the modified syntax tree, and replacing the character string constant in the syntax tree with the call of the GetString function.
Specifically, a GetString function is inserted into the syntax tree, and the type of the function is static char _ GetString (signaled int), and the function can return the elements in the static global pointer array by using the indexes of the global pointer array with static parameters. When the front end of the compiler modifies the syntax tree, the character string constant in the syntax tree is replaced by the call of the GetString function. And traversing the abstract syntax tree again, finding out the character string constant in the abstract syntax tree, and replacing the character string constant in the syntax tree with the call of the GetString function.
And S400, outputting the encrypted source code by the front end of the compiler according to the modified syntax tree.
Specifically, after the abstract syntax tree is modified, the front end of the compiler converts the abstract syntax tree into a source code and outputs the source code, and in the encrypted source code, a character string constant is encrypted and hidden and cannot be directly observed, so that the safety of the code is improved, and the code is prevented from being maliciously and reversely analyzed.
In a preferred embodiment, step S400 specifically includes:
step S410, creating a blank file, wherein the type of the blank file is consistent with that of the source file;
specifically, a blank C/C + + file is created, where the file has the same type as the original source file, and the same type means that when the original source file is a C file, the created blank file is a C file, and when the original source file is a C + + file, the created blank file is a C + + file. According to the type of the source file, a blank file is created in conformity with the type of the source file so that the file type of the output program is in conformity with the source file.
Step S420, outputting a header file contained in the source file to the blank file according to a correct syntax form;
specifically, the acquired header files, such as cstdio, stdio.h, and math.h, are output to the created blank file according to the syntax included in the header files. And outputting the header file to the blank file according to the syntactic form of the header file to obtain a semi-blank file of which the header file conforms to the header file of the source file.
And step S430, outputting the top-level statement in the grammar tree to the blank file according to a correct grammar form.
Specifically, the top-level declaration in the modified abstract syntax tree, such as a declaration or a defined global variable, is output to the created blank file in a correct syntax form, and the corresponding encrypted C/C + + source code is obtained through transformation and output according to the modified abstract syntax tree.
The encrypted code can change the character string constant of the code, the character string constant cannot be directly observed, the code becomes more difficult to understand, the code is prevented from being maliciously and reversely analyzed, and the finally output C/C + + code can be compiled by various compilers and can also be transplanted to various platforms.
When the program after the character string runs, the decryption function inserted in step S320 decrypts the first character array, and restores the encrypted character string constant to the original character string constant, the address of the first character of the original character string constant is stored in the static global pointer array inserted in step S310, the GetString function replaced in step S330 returns the corresponding character string pointer in the static global pointer array according to the order of the replaced character string constant, and the character string pointer points to the character string in the decrypted first character array, so that the GetString function calls to obtain the corresponding original character string. And returning the character string constant in the decrypted first character array to a corresponding position through a GetString function to obtain a source code, and completing decryption so that the program can normally run.
The encrypted output results are as follows:
it can be seen from the foregoing technical solutions that the present embodiment provides a method for implementing string confusion, specifically, a syntax tree corresponding to a source file and header files contained in the syntax tree are obtained by analyzing and processing the source file; modifying the syntax tree at the front end of the compiler; and outputting the encrypted source code by the front end of the compiler according to the modified syntax tree. Through the technical scheme, the abstract syntax tree at the front end of the compiler is modified, so that character strings are confused in the abstract syntax tree at the front end of the compiler, malicious reverse analysis of codes is avoided, and C/C + + source codes are obtained according to the output of the modified abstract syntax tree, so that the C/C + + source codes can be compiled by various compilers and can be transplanted to various platforms.
It should be noted that, for simplicity of description, the method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present invention is not limited by the illustrated order of acts, as some steps may occur in other orders or concurrently in accordance with the embodiments of the present invention. Further, those skilled in the art will appreciate that the embodiments described in the specification are presently preferred and that no particular act is required to implement the invention.
As shown in fig. 3, another embodiment of the present invention provides a system for implementing string obfuscation based on a compiler front end, including: the system comprises a code compiling module 10, an encryption modification module 20, a decryption modification module 30 and a code output module 40.
The code compiling module 10 is configured to analyze and process the source file to obtain a syntax tree corresponding to the source file and a header file included in the syntax tree.
The encryption modification module 20 is configured to perform encryption modification on the syntax tree, so that the string constants are encrypted.
The decryption modification module 30 is configured to perform decryption modification on the syntax tree to decrypt and restore the run-time string constants of the program.
The code output module 40 is configured to output, by the compiler front end, the obfuscated source code according to the modified abstract syntax tree.
For the system embodiment, the steps are arranged corresponding to the steps of the method embodiment, so that the description is relatively simple, and the relevant specification can refer to the partial description of the method embodiment.
The present invention also provides a device comprising at least one processor 50 and a memory 52, and may further comprise a communication interface 53, a bus 54 and a display screen 51. The processor 50, the display screen 51, the memory 52 and the communication interface 53 can communicate with each other through the bus 54. The display screen 51 is configured to display a user guidance interface preset in the initial setting mode. The communication interface 53 may transmit information. The processor 50 may process and invoke logic instructions in the memory 52 to perform the methods in the embodiments described above.
In the embodiments provided in the present invention, it should be understood that the disclosed method, system and apparatus can be implemented in other ways. For example, the above-described system embodiments are merely illustrative, and for example, the division of the modules is only one logical division, and other divisions may be realized in practice, for example, multiple units or components may be combined or integrated into another system, or some features may be omitted, or not executed. As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, apparatus, or computer program product. Accordingly, embodiments of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein. These computer program instructions may also be loaded onto a computer or other programmable data processing terminal to cause a series of operational steps to be performed on the computer or other programmable terminal to produce a computer implemented process such that the instructions which execute on the computer or other programmable terminal provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The embodiment of the invention also comprises a storage medium, wherein a program for realizing the method for realizing the character string confusion is stored.
Finally, it should be noted that: the above examples are only intended to illustrate the technical solution of the present invention, but not to limit it; although the present 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 solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions of the embodiments of the present invention.
Claims (9)
1. A method for realizing character string confusion is applied to a front end of a compiler and is characterized by comprising the following steps:
analyzing and processing the source file to obtain a syntax tree corresponding to the source file and a header file contained in the syntax tree;
encrypting and modifying the syntax tree to encrypt the character string constant;
carrying out operation decryption modification on the syntax tree to ensure that the character string constant is decrypted and restored when the program operates;
the obfuscated source code is output by the compiler front-end according to the modified syntax tree.
2. The method according to claim 1, wherein the step of encrypting and modifying the syntax tree to encrypt the string constants comprises:
a first character array and a second character array are inserted in the syntax tree.
3. The method for implementing string obfuscation as claimed in claim 2, wherein the step of inserting the first character array and the second character array in the syntax tree specifically includes:
traversing the syntax tree, collecting all character string constants in the syntax tree and recording the sequence of the character string constants;
encrypting the collected string constants by using a key;
inserting a first character array, wherein the first character array stores encrypted character string constants;
and inserting a second character array, wherein the second character array stores a secret key.
4. The method according to claim 3, wherein the run-time decryption modification is performed on the syntax tree, so that the run-time string constant decryption reduction step specifically includes: inserting a static global pointer array into the syntax tree;
inserting a decryption function, wherein the decryption function decrypts and restores the first character array when the program runs; inserting a GetString function, wherein the GetString function returns a decrypted character string constant specified by the parameter of the GetString function;
and traversing the modified syntax tree, and replacing the character string constant in the syntax tree with the call of the GetString function.
5. The method of claim 4, wherein the step of outputting the obfuscated source code from the compiler front-end modified syntax tree specifically comprises: creating a blank file, wherein the type of the blank file is consistent with that of the source file;
outputting a header file contained in the source file to the blank file in a correct syntax form;
and outputting the top-level declaration in the syntax tree to the blank file in a correct syntax form.
6. The method for implementing string obfuscation as claimed in claim 5, wherein the run-time decryption modification of the syntax tree is performed such that the run-time string constant decryption restoration process includes:
when the program runs, the decryption function decrypts the encrypted first character array;
storing the address of the first character of each character string constant in the decrypted first character array in a static global pointer array;
and the GetString function returns a corresponding character string pointer in the static global pointer array according to the sequence of the replaced character string constant, and the character string pointer points to the character string in the decrypted first character array, so that the GetString function calls to obtain a corresponding original character string.
7. A system for implementing string obfuscation, the system comprising:
the code compiling module is used for analyzing and processing the source file to obtain a grammar tree corresponding to the source file and a header file contained in the grammar tree;
the encryption modification module is used for carrying out encryption modification on the syntax tree so as to carry out encryption;
the decryption modification module is used for carrying out operation decryption modification on the syntax tree so as to decrypt and restore the character string constant when the program operates;
a code output module for outputting the obfuscated source code at a compiler front-end according to the modified syntax tree.
8. An apparatus for implementing character string obfuscation, characterized by: the device comprises a processor and a memory connected with the processor;
the memory stores a program for implementing string obfuscation, which when executed by the processor implements a method of implementing string obfuscation as claimed in any one of claims 1-6.
9. A storage medium storing a program for implementing the method of implementing character string obfuscation according to any one of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910897726.2A CN110598379B (en) | 2019-09-23 | 2019-09-23 | Method, equipment and storage medium for realizing character string confusion |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910897726.2A CN110598379B (en) | 2019-09-23 | 2019-09-23 | Method, equipment and storage medium for realizing character string confusion |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110598379A true CN110598379A (en) | 2019-12-20 |
| CN110598379B CN110598379B (en) | 2021-06-08 |
Family
ID=68862176
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910897726.2A Active CN110598379B (en) | 2019-09-23 | 2019-09-23 | Method, equipment and storage medium for realizing character string confusion |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110598379B (en) |
Cited By (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112256275A (en) * | 2020-10-22 | 2021-01-22 | 北京字节跳动网络技术有限公司 | Code obfuscation method, device, electronic device and medium |
| CN112347430A (en) * | 2020-10-28 | 2021-02-09 | 山东开创云计算有限公司 | IOS application reinforcement protection system |
| CN113434148A (en) * | 2021-06-30 | 2021-09-24 | 平安普惠企业管理有限公司 | Decryption-preventing client development compiling method and device, electronic equipment and storage medium |
| CN113449330A (en) * | 2021-08-31 | 2021-09-28 | 北京华云安信息技术有限公司 | Method for transmitting Javascript encrypted file |
| CN113591089A (en) * | 2021-08-12 | 2021-11-02 | 上海观安信息技术股份有限公司 | Data confusion encryption method |
| CN113641361A (en) * | 2021-06-28 | 2021-11-12 | 武汉极意网络科技有限公司 | Clang-based code hiding method and device |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2015035827A1 (en) * | 2013-09-13 | 2015-03-19 | Tencent Technology (Shenzhen) Company Limited | Method and apparatus for providing string encryption and decryption in program files |
| CN106326693A (en) * | 2016-08-18 | 2017-01-11 | 广州优视网络科技有限公司 | Obfuscation method and obfuscation device for application program code |
| CN108595921A (en) * | 2018-03-22 | 2018-09-28 | 北京奇艺世纪科技有限公司 | Character string obscures method and apparatus in a kind of source code |
| CN109241484A (en) * | 2018-09-06 | 2019-01-18 | 平安科技（深圳）有限公司 | A kind of sending method and equipment of the web data based on encryption technology |
| CN109598107A (en) * | 2018-11-20 | 2019-04-09 | 江苏通付盾信息安全技术有限公司 | A kind of code conversion method and device based on application installation package file |
| CN109992935A (en) * | 2019-03-15 | 2019-07-09 | 同盾控股有限公司 | A kind of source code guard method and device |
| CN110018814A (en) * | 2018-01-10 | 2019-07-16 | 武汉斗鱼网络科技有限公司 | Unique identifier providing method, storage medium, electronic equipment and system |
-
2019
- 2019-09-23 CN CN201910897726.2A patent/CN110598379B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2015035827A1 (en) * | 2013-09-13 | 2015-03-19 | Tencent Technology (Shenzhen) Company Limited | Method and apparatus for providing string encryption and decryption in program files |
| CN106326693A (en) * | 2016-08-18 | 2017-01-11 | 广州优视网络科技有限公司 | Obfuscation method and obfuscation device for application program code |
| CN110018814A (en) * | 2018-01-10 | 2019-07-16 | 武汉斗鱼网络科技有限公司 | Unique identifier providing method, storage medium, electronic equipment and system |
| CN108595921A (en) * | 2018-03-22 | 2018-09-28 | 北京奇艺世纪科技有限公司 | Character string obscures method and apparatus in a kind of source code |
| CN109241484A (en) * | 2018-09-06 | 2019-01-18 | 平安科技（深圳）有限公司 | A kind of sending method and equipment of the web data based on encryption technology |
| CN109598107A (en) * | 2018-11-20 | 2019-04-09 | 江苏通付盾信息安全技术有限公司 | A kind of code conversion method and device based on application installation package file |
| CN109992935A (en) * | 2019-03-15 | 2019-07-09 | 同盾控股有限公司 | A kind of source code guard method and device |
Cited By (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112256275A (en) * | 2020-10-22 | 2021-01-22 | 北京字节跳动网络技术有限公司 | Code obfuscation method, device, electronic device and medium |
| CN112256275B (en) * | 2020-10-22 | 2023-09-29 | 抖音视界有限公司 | Code confusion method, device, electronic equipment and medium |
| CN112347430A (en) * | 2020-10-28 | 2021-02-09 | 山东开创云计算有限公司 | IOS application reinforcement protection system |
| CN113641361A (en) * | 2021-06-28 | 2021-11-12 | 武汉极意网络科技有限公司 | Clang-based code hiding method and device |
| CN113641361B (en) * | 2021-06-28 | 2024-01-26 | 武汉极意网络科技有限公司 | Code hiding method and device based on Clang |
| CN113434148A (en) * | 2021-06-30 | 2021-09-24 | 平安普惠企业管理有限公司 | Decryption-preventing client development compiling method and device, electronic equipment and storage medium |
| CN113434148B (en) * | 2021-06-30 | 2024-03-22 | 广东迅维信息产业股份有限公司 | Decryption-preventing client development compiling method and device, electronic equipment and storage medium |
| CN113591089A (en) * | 2021-08-12 | 2021-11-02 | 上海观安信息技术股份有限公司 | Data confusion encryption method |
| CN113449330A (en) * | 2021-08-31 | 2021-09-28 | 北京华云安信息技术有限公司 | Method for transmitting Javascript encrypted file |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110598379B (en) | 2021-06-08 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110598379B (en) | Method, equipment and storage medium for realizing character string confusion | |
| CN108595921B (en) | Method and device for confusing character strings in source codes | |
| US20160203087A1 (en) | Method for providing security for common intermediate language-based program | |
| US8539459B2 (en) | Code obfuscation and controlling a processor by emulation | |
| US9607160B2 (en) | Method and apparatus for providing string encryption and decryption in program files | |
| CN105354449A (en) | Scrambling and obfuscating method for Lua language and decryption method | |
| CN111240654B (en) | Python code reinforcement protection method and system | |
| CN110569628B (en) | Code obfuscation method and device, computer device and storage medium | |
| CN108762788B (en) | Method and system for encrypting firmware of embedded equipment based on server | |
| CN113569269B (en) | Encryption method, device, equipment and readable medium for code obfuscation | |
| CN110008662B (en) | Application program running method and device, electronic equipment and readable storage medium | |
| EP3729306B1 (en) | Compiling device and method | |
| CN111819542A (en) | Compiling apparatus and method | |
| JP6698774B2 (en) | Security providing apparatus and method for common intermediate language, and security executing apparatus and method | |
| CN110673852A (en) | Method, system and equipment for realizing control flow flatness based on compiler front end | |
| CN112115427A (en) | Code obfuscation method, device, electronic device and storage medium | |
| CN107871066B (en) | Code compiling method and device based on android system | |
| CN108932407B (en) | Program safety protection method and device | |
| CN113626773B (en) | Code protection method based on intermediate language | |
| CN112052461A (en) | Code processing method based on instruction injection, terminal and storage medium | |
| CN116257867A (en) | Secret key encryption method and device | |
| CN113434148B (en) | Decryption-preventing client development compiling method and device, electronic equipment and storage medium | |
| CN113282294A (en) | Android platform-based Java character string confusion method and device | |
| CN114968206A (en) | Dynamic confusion method and system for programming language codes | |
| CN114139117A (en) | Application program reinforcing method and device, electronic 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 |