CN112256275B - Code confusion method, device, electronic equipment and medium - Google Patents
Code confusion method, device, electronic equipment and medium Download PDFInfo
- Publication number
- CN112256275B CN112256275B CN202011141687.2A CN202011141687A CN112256275B CN 112256275 B CN112256275 B CN 112256275B CN 202011141687 A CN202011141687 A CN 202011141687A CN 112256275 B CN112256275 B CN 112256275B
- Authority
- CN
- China
- Prior art keywords
- function
- built
- constant
- confused
- source code
- 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
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
-
- 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
- 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
Abstract
The embodiment of the disclosure provides a code confusion method, a device, electronic equipment and a medium. The method comprises the following steps: acquiring a source code file of a target application program, wherein the source code file comprises a preconfigured built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file; in the compiling process of the source code file, determining a constant character string to be confused selected in the built-in function as a target constant character string; and performing confusion processing on the target constant character string. The embodiment of the disclosure reduces the volume of the application program, improves the performance of the application program and improves the user experience.
Description
Technical Field
The disclosure relates to the technical field of computer security, in particular to a code confusion method, a code confusion device, an electronic device and a medium.
Background
In the process of performing reverse cracking on an application program, a reverse person generally needs to locate the position of a key function, so how to protect the application program and increase the attack cost of the reverse person become an important problem.
In the prior art, source codes of application programs can be confused to protect the application programs and improve the attack cost of reverse personnel. However, after the source code of the application program is confused, the decrypted code needs to be inserted in an inline mode, which leads to the increase of the volume of the application program, and meanwhile, when the application program runs, the confused source code needs to be decrypted, the decryption process takes longer time, the performance of the application program can be influenced, and the user experience is poor.
Disclosure of Invention
The disclosure provides a code confusion method, a code confusion device, electronic equipment and a code confusion medium, which can solve the technical problems of larger application program size and poorer performance.
In a first aspect, a code obfuscation method is provided, the method including:
acquiring a source code file of a target application program, wherein the source code file comprises a preset built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
in the compiling process of the source code file, determining a constant character string to be confused selected in the built-in function as a target constant character string;
and performing confusion processing on the target constant character string.
In a second aspect, there is provided a code obfuscation apparatus, the apparatus comprising:
The acquisition module is used for acquiring a source code file of the target application program, wherein the source code file comprises a preset built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
the determining module is used for determining constant character strings to be confused selected in the built-in function as target constant character strings in the process of compiling the source code file;
and the confusion module is used for carrying out confusion processing on the target constant character string.
In a third aspect, an electronic device is provided, the electronic device comprising:
one or more processors;
a memory;
one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more applications configured to: the operations corresponding to the code obfuscation method according to the first aspect are performed.
In a fourth aspect, a computer readable medium is provided, on which a computer program is stored which, when executed by a processor, implements the code obfuscation method of the first aspect.
The beneficial effects that this disclosure provided technical scheme brought are:
compared with the prior art, the method and the device for code confusion are characterized in that the source code file of a target application program is obtained, the source code file comprises a preset built-in function, the built-in function is used for selecting constant strings to be confused in the source code file, and the constant strings to be confused selected in the built-in function are determined to serve as target constant strings in the process of compiling the source code file and are subjected to confusion processing. The confusion processing is carried out on the target constant character strings in the built-in functions of the source code files, so that the code quantity to be confused can be reduced, on one hand, the decrypted codes to be inserted are reduced, the volume of an application program is reduced, on the other hand, the time consumption of the decryption process is reduced during operation, the performance of the application program is improved, and the user experience is improved.
Drawings
The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements. It should be understood that the figures are schematic and that elements and components are not necessarily drawn to scale.
Fig. 1 is a schematic flow chart of a code obfuscation method according to an embodiment of the disclosure;
fig. 2 is a schematic structural diagram of a code obfuscating apparatus according to an embodiment of the present disclosure;
fig. 3 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure.
Detailed Description
Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.
It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.
The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.
It should be noted that the terms "first," "second," and the like in this disclosure are used merely to distinguish one device, module, or unit from another device, module, or unit, and are not intended to limit the order or interdependence of the functions performed by the devices, modules, or units.
It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those of ordinary skill in the art will appreciate that "one or more" is intended to be understood as "one or more" unless the context clearly indicates otherwise.
The names of messages or information interacted between the various devices in the embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.
The following describes the technical solutions of the present disclosure and how the technical solutions of the present disclosure solve the above technical problems in detail with specific embodiments. The following embodiments may be combined with each other, and the same or similar concepts or processes may not be described in detail in some embodiments. Embodiments of the present disclosure will be described below with reference to the accompanying drawings.
The embodiment of the disclosure provides a code confusion method, which may be executed by an electronic device, and the electronic device may be a terminal device such as a mobile terminal, a desktop computer, a notebook computer, or a server, as shown in fig. 1, and the method includes steps S101 to S103.
Step S101, a source code file of a target application program is acquired.
The source code file comprises a preset built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file.
In the embodiment of the present disclosure, a compiler may be preset in the electronic device, and the compiler performs steps S101 to S103.
The compiler may be an underlying virtual machine (Low Level Virtual Machine, LLVM), the LLVM includes a compiler front end and a compiler back end, the compiler front end is Clang, the compiler front end may perform lexical and grammatical analysis on a source code file, generate an abstract grammar tree (Abstract Syntax Tree, AST), and convert the AST into an intermediate representation (Intermediate Representation, IR), and the compiler back end may convert the IR into binary code, that is, an executable program corresponding to the source code file.
In the embodiment of the present disclosure, at least one built-in function preconfigured in the source code file may be the same function or may be different functions. For example, the function name of at least one built-in function may be __ building_str_obfuscation. Of course, any two of the at least one built-in functions may be the same function or may be different functions, for example, the function names of the respective built-in functions may be different.
It should be noted that, the classification is performed according to the function name of at least one built-in function, and each type of built-in function may be predefined in the compiler. Specifically, various built-in functions may be predefined at the compiler front end. For example, the following built-in functions are predefined in Clang:
BUILTIN(__builtin_str_obfuscation,"c*c*","")
the BUILTIN characterization function __ builtin_str_obfuscation is a built-in function of the compiler; __ building_str_obfuscation is the function name of the built-in function; the type of the input parameter of the characterization function __ builtin_str_obfuscation is char, and the type of the return value is char; "characterizes the attribute of the function __ build_str_obfuscation, here set to null.
Correspondingly, the source code file may also define various built-in functions in advance, for example, the following built-in functions may be predefined in the source code file:
char*__builtin_str_obfuscation(char*)
The first char characterization function __ building_str_obfuscation parameter type is char; the second char represents __ folltin_str_obfuscation return value type is char; __ building_str_obfuscation is the function name of the built-in function.
By predefining various built-in functions in the source code file, when the source code file is written, various predefined built-in functions can be used for protecting constant character strings to be confused, namely the built-in functions are used for selecting at least one constant character string to be confused in the source code file, so that the obtained source code file comprises at least one pre-configured built-in function, and parameters of the built-in functions comprise at least one constant character string to be confused, which is pre-selected from the source code file.
For example, source code that protects constant strings to be confused without using built-in functions is as follows:
printf("％s","import_string")；
wherein printf is a formatted output function; "% s" indicates that no conversion is performed, and the output string itself; "import_string" is a constant string to be confused.
The source code for protecting the constant string to be confused using the built-in function is as follows:
printf("％s",__builtin_str_obfuscation("import_string"))
wherein printf is a formatted output function; "% s" indicates that no conversion is performed, and the output string itself; __ building_str_obfuscation is the function name of the built-in function; "import_string" is a constant string to be confused.
Similarly, in the above manner, a built-in function may be called on each constant string to be confused, so as to protect each constant string to be confused by using the built-in function, for example, "import_string" in the above code is the constant string to be confused.
Step S102, determining a constant character string to be confused selected in the built-in function as a target constant character string in the process of compiling the source code file.
In the embodiment of the disclosure, at least one built-in function in a source code file can be identified by compiling the source code file, and each target constant string in each built-in function can be identified for each built-in function.
For example, if the source code file includes printf ("%s", __ building_str_obfuscation ("import_string")), the built-in function __ building_str_obfuscation may be first identified by compiling the source code file, and then the constant string "import_string" to be confused in the built-in function may be identified, and the "import_string" may be used as the target constant string.
Step S103, performing confusion processing on the target constant character string.
In the embodiment of the disclosure, the encryption processing, which is also called confusion processing, may be performed on each target constant string by using a preset encryption algorithm.
Compared with the prior art, the method for confusion of the code provided by the embodiment of the disclosure has the advantages that the source code file of the target application program is obtained, the source code file comprises a preset built-in function, the built-in function is used for selecting constant strings to be confused in the source code file, and in the process of compiling the source code file, the constant strings to be confused selected in the built-in function are determined and used as target constant strings, and confusion processing is carried out on the target constant strings. The confusion processing is carried out on the target constant character strings in the built-in functions of the source code files, so that the code quantity to be confused can be reduced, on one hand, the decrypted codes to be inserted are reduced, the volume of an application program is reduced, on the other hand, the time consumption of the decryption process is reduced during operation, the performance of the application program is improved, and the user experience is improved.
In another possible implementation manner of the embodiment of the present application, step S103, performing confusion processing on the target constant string may specifically include: encrypting the target constant character string by using the secret key to obtain ciphertext information; and replacing the target constant character string with the ciphertext information.
Specifically, for each target constant string, the target constant string may be encrypted with a key to obtain ciphertext information, and the target constant string may be replaced with the obtained ciphertext information.
In particular implementations, storage space may be allocated within the global variable region for storing ciphertext information. Ciphertext information may be represented by the variable global_cipheret, keys by the constant_key, and target constant strings by the variable origin_text. For each target constant string, after encrypting the target constant string, the original origin_text may be replaced by the obtained global_cipheret, that is, the target constant string may be replaced by the obtained ciphertext information.
Of course, when the target constant string is replaced with the obtained ciphertext information, a decryption function may be inserted first, and then the target constant string may be replaced with the obtained ciphertext information.
In implementation, when the original origin_text is replaced by the obtained global_cipheret, a storage space may be allocated in a stack space of a function using the variable origin_text to store the decrypted plaintext, and the decrypted plaintext may be represented by the variable local_cleartext. Inserting a decryption function in or before or after a function using the origin_text, then replacing the use of the origin_text with a local_clean_text, then deleting the origin_text, and replacing the original local_clean_text with the obtained global_clean_text, wherein the local_clean_text is identical to the origin_text.
Correspondingly, when the electronic device wants to run the source code file after confusion processing, the electronic device needs to decrypt the ciphertext information by using the secret key to obtain a decrypted constant character string, and replaces the ciphertext information with the decrypted constant character string.
It should be noted that, the decryption step may be performed in the electronic device that performs the encryption step, that is, the decryption step may be performed in the execution body of the embodiment of the present application, or may be performed in other electronic devices. In other words, after the obfuscation process is performed on the target constant string in the source code file, any electronic device that wants to run the obfuscated source code file needs to perform the decryption step.
When the method is operated, the inserted decryption function can be utilized to decrypt each ciphertext message, and a decrypted constant character string, namely a target constant character string, is obtained. Specifically, for each piece of ciphertext information, the ciphertext information is decrypted by using the key to obtain a target constant string, and the ciphertext information is replaced by the obtained target constant string.
In a specific implementation, the decryption function may decrypt global_ciphereext using the const_key, obtain a decrypted plaintext, and store the decrypted plaintext into local_cleartext.
Another possible implementation of an embodiment of the disclosure includes a preconfigured macro function in a header file of a source code file, the macro function being used to define a built-in function.
In other words, the header file of the source code file defines a macro function corresponding to the built-in function, and the parameter of the macro function includes at least one constant character string to be confused, which is preselected from the source code file.
In the embodiment of the disclosure, the macro function corresponding to the built-in function can be defined in the header file of the source code file, and when the built-in function is used, the macro function can be directly used for protecting the constant character strings to be confused. Because each function in the source code file needs to be predefined, the built-in function is defined in the header file, the built-in function can be defined only once, codes required for defining the built-in function are reduced, the volume of the source code file is effectively reduced, and the macro function is used for protecting constant character strings to be confused, so that the call of the built-in function tends to be simplified.
For example, a header file may be added to the source code file, and the following built-in functions may be defined in the header file:
#if__has_builtin(__builtin_str_obfuscation)
#ifndef OBF
#define OBF__builtin_str_obfuscation
#endif
#else
#ifndef OBF
#define OBF
#endif
#endif
as can be seen from the definition of the built-in function, the macro function corresponding to the built-in function __ building_str_obfuscation is OBF.
When the built-in function is used for protecting the constant character strings to be confused, the macro function can be used for protecting the constant character strings to be confused.
For example, for printf ("% s", __ build_str_obfuscation ("import_string")), the code protects the constant string "import_string" to be confused with the built-in function __ build_str_obfuscation. When a macro function OBF corresponding to the built-in function is defined in the header file of the source code file, the code may be printf ("% s", OBF ("import_string")), and the Li Yonghong function OBF in the code protects the constant string "import_string" to be confused.
In another possible implementation manner of the embodiment of the present disclosure, in step S102, in the process of compiling the source code file, a constant string to be confused selected in the built-in function is determined, which may specifically include step S1021 and step S1022.
Step S1021, in the process of compiling the source code file, an abstract syntax tree is obtained, and each node in the abstract syntax tree represents each function in the source code file.
Step S1022, for each node in the abstract syntax tree, if the node is a node corresponding to the built-in function, determining a constant character string to be confused selected in the built-in function for the node.
In the embodiment of the disclosure, the front end of the compiler may compile the source code file to obtain an AST, where AST is an abstract representation of a syntax structure of the source code, and represents the syntax structure of the programming language in a tree form, and each node on the tree represents a structure in the source code. In the embodiment of the disclosure, each node on the AST corresponds to each function in the source code file.
In the embodiment of the disclosure, in the process of converting an AST into an IR, each node on the AST can be sequentially traversed, and for a currently traversed node, if a function name of a built-in function is included in a function corresponding to the currently traversed node, the currently traversed node is the node corresponding to the built-in function, and each constant character string to be confused in the built-in function can be identified.
For example, the function corresponding to the currently traversed node includes a function name __ building_str_obfuscation of the built-in function, and if the currently traversed node is a node corresponding to __ building_str_obfuscation, each constant character string to be confused in __ building_str_obfuscation can be identified, for example, a constant character string 'import_string' to be confused in __ building_str_obfuscation can be identified.
In another possible implementation manner of the embodiment of the present disclosure, in step S102, the constant strings to be confused selected in the built-in function are determined, which may specifically include step S1023.
Step S1023, for each built-in function in at least one built-in function, recognizing the constant character strings to be confused in the built-in function according to the expression form of the built-in function in the compiling process.
It should be noted that, in step S1023, a specific implementation manner of determining the constant string to be confused selected in the built-in function in step S1022, that is, determining the constant string to be confused in the built-in function, specifically, may identify the constant string to be confused in the built-in function according to a representation form of the built-in function in a compiling process.
Specifically, in step S102, the constant string to be confused selected in the built-in function is determined, which may specifically include step S1024 and step S1025. Step S1024 and step S1025 may also be specific implementation manner of "identify constant strings to be confused in the built-in function" in step S1023.
In step S1024, if the type of the parameter of the built-in function is a constant expression, the target operand is determined from the expression form corresponding to the constant expression of the parameter.
In the embodiment of the disclosure, if the type of the parameter of the built-in function is a constant expression, the parameter is converted into a representation form corresponding to the constant expression.
In the embodiment of the disclosure, the constant expression is constantaxpr, and if the type of the parameter of the built-in function is constantan expr, the parameter is converted into a representation form corresponding to constantan expr. For example, the parameters may be converted into corresponding manifestations of constantaxpr as shown below:
i8*getelementptr inbounds([7x i8],[7x i8]*@.str,i32 0,i32 0)
wherein, the expression form corresponding to ConstantExpr comprises three operands which are @. Str, 0 and 0 respectively, and the types corresponding to the three operands are [ 7xi8 ], i32 and i32 respectively. In the embodiment of the present disclosure, only these three operands and the respective types may be focused, and the remainder will not be focused, and will not be discussed here.
When a constant string is used in IR, the string is present in a form corresponding to the constant expression constantan expr.
Further, a target operand may be identified from the converted parameter.
In the embodiment of the disclosure, for the converted parameter, a target operand may be identified in each operand of the converted parameter.
For example, for i8× getelementptr inbounds ([ 7xi8 ], [ 7xi8 ] @, str, i32 0), the target operand @ str can be identified from the three operands @, str, 0, and 0 of the converted parameter.
In identifying a target operand from the converted parameter, an operand at a predetermined position in the converted parameter may be used as the target operand, for example, a first operand @ str of the converted parameter may be used as the target operand; the type corresponding to the target operand may also be determined from the types of the respective operands, and the operand corresponding to the determined type is used as the target operand, for example, the type of the target operand is determined to be [ 7xi8 ], i32 and i32 from the types of three operands, so that the operand @ str corresponding to [ 7xi8 ] and [ 7xi8 ] is determined as the target operand; other ways of identifying target operands are possible and are not exhaustive herein.
In step S1025, if the type of the target operand is a global variable, a constant string is determined from the representation form corresponding to the global variable of the target operand, and is used as the constant string to be confused.
In the embodiment of the disclosure, constant strings to be confused in the built-in function, namely target constant strings, can be determined based on the target operands. Specifically:
and if the type of the target operand is a global variable, converting the target operand into a representation form corresponding to the global variable.
In the embodiment of the disclosure, the global variable is GlobalVariable, and if the type of the target operand is GlobalVariable, the target operand is converted into a representation form corresponding to GlobalVariable. For example, the destination operand @ str may be converted to a representation corresponding to Global variable as shown below:
@.str＝private unnamed_addr constant[7x i8]c"hello\0A\00",align 1
the expression form corresponding to the global variable is the expression form of a constant character string hello in IR, and the constant character string exists in the form of global variable in IR.
Further, a target constant string is identified from the converted target operand.
In the embodiment of the disclosure, the target constant string may be identified from the converted target operand, for example, from @ str=private unamed_addr constant [7x i8]c"hello\0A\00 ], and the target constant string hello may be identified from align 1.
In another possible implementation manner of the embodiment of the present disclosure, the code obfuscation method provided by the embodiment of the present disclosure may further include step S104.
Step S104, after the constant character strings to be confused are determined, adding marks to be confused to the constant character strings to be confused.
In the embodiment of the disclosure, adding the to-be-confused flag to the to-be-confused constant string may be adding the attribute addAttribute to the to-be-confused constant string, that is, the to-be-confused flag may be a confusion attribute, where the to-be-confused constant string may also be referred to as a target constant string. Specifically, after each target constant string is identified, a confusion attribute may be added to the target constant string, where the confusion attribute is used as a flag to be confused with the target constant string, and then parameters of the built-in function are returned.
For example, a confusion attribute "str_ obf" may be added to the target constant string hello and parameters of the built-in function returned.
Then, in step S103, the confusion process is performed on the target constant string, which may specifically include step S1031.
In step S1031, confusion processing is performed on the constant string with the flag to be confused.
In the embodiment of the disclosure, each target constant string with the to-be-obfuscated flag may be subjected to encryption processing, for example, the target constant string with the obfuscated attribute str_ obf may be subjected to encryption processing. The encryption processing manner may be described in detail in the above embodiments, and will not be described herein.
For further systematic understanding of the technical solution of the present disclosure, a pseudo code is provided below, which is as follows:
if (function is __ block_str_obfuscation) {
Acquiring parameters of the function and storing the parameters in a variable Arg0
if (Arg 0 type is ConstantExpr) {
Arg0 is converted to a corresponding representation of ConstantExpr and stored in variable CE.
The first operand of the variable CE is obtained and stored in the variable Op.
if (Op type is global variable) {
Op is converted into a representation corresponding to GlobalVariable and stored in variable GV.
Identifying the target constant string from GV and adding the confusion attribute "str_ obf" }
Return Arg0}
As can be seen from the above code, when it is detected that the node currently traversed (the node corresponds to a function) is the node corresponding to the built-in function __ block_str_obfuscation, that is, the function is __ block_str_obfuscation, the parameter is obtained from the function and stored in the variable Arg0, and the parameter of the built-in function is represented by Arg 0; if the type of Arg0 is ConstantExpr, converting Arg0 into a representation form corresponding to ConstantExpr, storing the representation form into a variable CE, using CE to represent the converted Arg0, obtaining a first operand of the variable CE, storing the first operand into a variable Op, and using Op to represent a target operand; if the type of the Op is global variable GlobalVariable, converting the Op into a representation form corresponding to the GlobalVariable, storing the representation form into a variable GV, using the GV to represent the converted Op, identifying a target constant character string from the GV, adding a confusion attribute str_ obf, and returning to Arg0.
The above-mentioned method steps specifically illustrate the code obfuscation method, and the code obfuscation apparatus is described below from the viewpoint of the virtual module, specifically as follows:
the disclosed embodiments provide a code obfuscation apparatus, as shown in fig. 2, the code obfuscation apparatus 20 may include: an acquisition module 201, a determination module 202, and a confusion module 203, wherein,
The obtaining module 201 is configured to obtain a source code file of a target application program, where the source code file includes a pre-configured built-in function, and the built-in function is used to select a constant string to be confused in the source code file.
The determining module 202 is configured to determine, as a target constant string, a constant string to be confused selected in the built-in function in a process of compiling the source code file.
And the confusion module 203 is configured to perform confusion processing on the target constant string.
In another possible implementation manner of the embodiment of the present disclosure, the determining module 202 is specifically configured to:
in the process of compiling the source code file, an abstract syntax tree is obtained, and each node in the abstract syntax tree represents each function in the source code file;
for each node in the abstract syntax tree, if the node is a node corresponding to the built-in function, determining a constant character string to be confused selected in the built-in function according to the node.
In another possible implementation manner of the embodiment of the present disclosure, the determining module 202 is specifically configured to, when determining a constant string to be confused selected in the built-in function:
when the type of the parameter of the built-in function is a constant expression, determining a target operand from the expression form corresponding to the constant expression of the parameter;
And when the type of the target operand is a global variable, determining a constant character string from the expression form corresponding to the global variable of the target operand as the constant character string to be confused.
Another possible implementation of an embodiment of the present disclosure, the code obfuscation apparatus 20 further includes an addition module, where,
the adding module is used for adding a to-be-confused mark to the constant character strings to be confused after the constant character strings to be confused are determined;
the confusion module 203 is specifically configured to:
and performing confusion processing on the constant character strings with the marks to be confused.
In another possible implementation manner of the embodiment of the present disclosure, a header file of a source code file includes a preconfigured macro function, and the macro function is used to define the built-in function.
Another possible implementation of the embodiment of the disclosure, the confusion module 203 is specifically configured to:
encrypting the target constant character string by using the secret key to obtain ciphertext information;
and replacing the target constant character string with the ciphertext information.
The code obfuscation apparatus 20 according to the embodiments of the present disclosure may perform the code obfuscation method according to any of the foregoing embodiments of the present disclosure, and the implementation principle is similar, and will not be repeated here.
Compared with the prior art, the method and the device for obfuscating the code provided by the embodiment of the disclosure have the advantages that the source code file of the target application program is obtained, the source code file comprises a preset built-in function, the built-in function is used for selecting constant strings to be obfuscated in the source code file, and in the process of compiling the source code file, the constant strings to be obfuscated selected in the built-in function are determined and used as target constant strings, and obfuscating processing is carried out on the target constant strings. The confusion processing is carried out on the target constant character strings in the built-in functions of the source code files, so that the code quantity to be confused can be reduced, on one hand, the decrypted codes to be inserted are reduced, the volume of an application program is reduced, on the other hand, the time consumption of the decryption process is reduced during operation, the performance of the application program is improved, and the user experience is improved.
The code obfuscation apparatus of the present disclosure is described above from the viewpoint of a virtual module, and the electronic device of the present disclosure is described below from the viewpoint of a physical apparatus.
Referring now to fig. 3, a schematic diagram of an electronic device (e.g., a terminal device or server in fig. 1) 300 suitable for use in implementing embodiments of the present disclosure is shown. Wherein the electronic device 300 comprises:
one or more processors;
a memory;
one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more applications configured to: the code obfuscation method shown according to the method embodiment is performed.
The terminal devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and the like, and stationary terminals such as digital TVs, desktop computers, and the like. The electronic device shown in fig. 3 is merely an example and should not be construed to limit the functionality and scope of use of the disclosed embodiments.
An electronic device includes: a memory and a processor, where the processor may be referred to as a processing device 301 described below, the memory may include at least one of a Read Only Memory (ROM) 302, a Random Access Memory (RAM) 303, and a storage device 308 described below, as follows:
as shown in fig. 3, the electronic device 300 may include a processing means (e.g., a central processing unit, a graphics processor, etc.) 301 that may perform various suitable actions and processes in accordance with a program stored in a Read Only Memory (ROM) 302 or a program loaded from a storage means 308 into a Random Access Memory (RAM) 303. In the RAM 303, various programs and data required for the operation of the electronic apparatus 300 are also stored. The processing device 301, the ROM 302, and the RAM 303 are connected to each other via a bus 304. An input/output (I/O) interface 305 is also connected to bus 304.
In general, the following devices may be connected to the I/O interface 305: input devices 306 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; an output device 307 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 308 including, for example, magnetic tape, hard disk, etc.; and communication means 309. The communication means 309 may allow the electronic device 300 to communicate with other devices wirelessly or by wire to exchange data. While fig. 3 shows an electronic device 300 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.
In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a non-transitory computer readable medium, the computer program comprising program code for performing the method shown in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network via a communication device 309, or installed from a storage device 308, or installed from a ROM 302. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing means 301.
It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.
In some implementations, the clients, servers may communicate using any currently known or future developed network protocol, such as HTTP (HyperText Transfer Protocol ), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the internet (e.g., the internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed networks.
The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.
The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: acquiring a source code file of a target application program, wherein the source code file comprises a preconfigured built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file; in the compiling process of the source code file, determining a constant character string to be confused selected in the built-in function as a target constant character string; and performing confusion processing on the target constant character string.
Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including, but not limited to, an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider).
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The modules or units involved in the embodiments of the present disclosure may be implemented by means of software, or may be implemented by means of hardware. Where the name of the module or unit does not constitute a limitation on the unit itself in some cases, for example, the acquisition module may also be described as "a module that acquires a source code file of a target application".
The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.
In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
The embodiment of the disclosure provides an electronic device, which includes: a memory and a processor; at least one program stored in the memory for execution by the processor, which when executed by the processor, performs: the method comprises the steps of obtaining a source code file of a target application program, wherein the source code file comprises a preset built-in function, the built-in function is used for selecting constant strings to be confused in the source code file, determining the constant strings to be confused selected in the built-in function as target constant strings in the process of compiling the source code file, and carrying out confusion processing on the target constant strings. The confusion processing is carried out on the target constant character strings in the built-in functions of the source code files, so that the code quantity to be confused can be reduced, on one hand, the decrypted codes to be inserted are reduced, the volume of an application program is reduced, on the other hand, the time consumption of the decryption process is reduced during operation, the performance of the application program is improved, and the user experience is improved.
The electronic apparatus of the present disclosure is described above in terms of a physical device, and the computer-readable medium of the present disclosure is described below in terms of a medium.
The disclosed embodiments provide a computer readable medium having a computer program stored thereon, which when run on a computer, causes the computer to perform the corresponding method embodiments described above. Compared with the prior art, the method comprises the steps of acquiring a source code file of a target application program, wherein the source code file comprises a preset built-in function, the built-in function is used for selecting constant strings to be confused in the source code file, determining the constant strings to be confused selected in the built-in function as target constant strings in the process of compiling the source code file, and carrying out confusion processing on the target constant strings. The confusion processing is carried out on the target constant character strings in the built-in functions of the source code files, so that the code quantity to be confused can be reduced, on one hand, the decrypted codes to be inserted are reduced, the volume of an application program is reduced, on the other hand, the time consumption of the decryption process is reduced during operation, the performance of the application program is improved, and the user experience is improved.
According to one or more embodiments of the present disclosure, there is provided a code obfuscation method including:
acquiring a source code file of a target application program, wherein the source code file comprises a preconfigured built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
In the compiling process of the source code file, determining a constant character string to be confused selected in the built-in function as a target constant character string;
and performing confusion processing on the target constant character string.
According to one or more embodiments of the present disclosure, the determining, in the compiling process of the source code file, a constant string to be confused selected in the built-in function includes:
in the process of compiling the source code file, obtaining an abstract syntax tree, wherein each node in the abstract syntax tree represents each function in the source code file;
and for each node in the abstract syntax tree, if the node is the node corresponding to the built-in function, determining the constant character string to be confused selected in the built-in function for the node.
According to one or more embodiments of the present disclosure, the determining the constant string to be confused selected in the built-in function includes:
if the type of the parameter of the built-in function is a constant expression, determining a target operand from a representation form corresponding to the constant expression of the parameter;
and if the type of the target operand is a global variable, determining a constant character string from the expression form corresponding to the global variable of the target operand, and taking the constant character string as the constant character string to be confused.
According to one or more embodiments of the present disclosure, the method further comprises:
after the constant character strings to be confused are determined, adding marks to be confused to the constant character strings to be confused;
and performing confusion processing on the target constant character string, wherein the confusion processing comprises the following steps:
and carrying out confusion processing on the constant character strings with the marks to be confused.
According to one or more embodiments of the present disclosure, a header file of the source code file includes a preconfigured macro function therein, the macro function being used to define the built-in function.
According to one or more embodiments of the present disclosure, the obfuscating the target constant string includes:
encrypting the target constant character string by using a secret key to obtain ciphertext information;
and replacing the target constant character string with the ciphertext information.
According to one or more embodiments of the present disclosure, there is provided a code obfuscation apparatus, including:
the acquisition module is used for acquiring a source code file of a target application program, wherein the source code file comprises a preset built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
The determining module is used for determining the constant character strings to be confused selected in the built-in function as target constant character strings in the process of compiling the source code file;
and the confusion module is used for carrying out confusion processing on the target constant character string.
According to one or more embodiments of the present disclosure, the determining module is specifically configured to:
in the process of compiling the source code file, obtaining an abstract syntax tree, wherein each node in the abstract syntax tree represents each function in the source code file;
and for each node in the abstract syntax tree, if the node is the node corresponding to the built-in function, determining the constant character string to be confused selected in the built-in function for the node.
According to one or more embodiments of the present disclosure, the determining module is specifically configured to, when determining a constant string to be confused selected in the built-in function:
when the type of the parameter of the built-in function is a constant expression, determining a target operand from a representation form corresponding to the constant expression of the parameter;
and when the type of the target operand is a global variable, determining a constant character string from the expression form corresponding to the global variable of the target operand as the constant character string to be confused.
According to one or more embodiments of the present disclosure, the apparatus further comprises:
the adding module is used for adding a to-be-confused mark to the constant character string to be confused after the constant character string to be confused is determined;
the confusion module is specifically configured to:
and carrying out confusion processing on the constant character strings with the marks to be confused.
According to one or more embodiments of the present disclosure, a header file of the source code file includes a preconfigured macro function therein, the macro function being used to define the built-in function.
According to one or more embodiments of the present disclosure, the obfuscation module is specifically configured to:
encrypting the target constant character string by using a secret key to obtain ciphertext information;
and replacing the target constant character string with the ciphertext information.
According to one or more embodiments of the present disclosure, there is provided an electronic device including:
one or more processors;
a memory;
one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more applications configured to: the code obfuscation method shown according to the method embodiment is performed.
According to one or more embodiments of the present disclosure, there is provided a computer-readable medium having stored thereon a computer program which, when executed by a processor, implements a code obfuscation method as shown in the method embodiments.
The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).
Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.
Claims (8)
1. A method of code obfuscation, comprising:
acquiring a source code file of a target application program, wherein the source code file comprises a preconfigured built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
in the compiling process of the source code file, determining a constant character string to be confused selected in the built-in function as a target constant character string; wherein, the determining the constant character string to be confused selected in the built-in function includes: if the type of the parameter of the built-in function is a constant expression, determining a target operand from a representation form corresponding to the constant expression of the parameter; if the type of the target operand is a global variable, determining a constant character string from a representation form corresponding to the global variable of the target operand, wherein the constant character string is used as a constant character string to be confused;
And performing confusion processing on the target constant character string.
2. The method according to claim 1, wherein determining the constant strings to be confused selected in the built-in function in the compiling process of the source code file comprises:
in the process of compiling the source code file, obtaining an abstract syntax tree, wherein each node in the abstract syntax tree represents each function in the source code file;
and for each node in the abstract syntax tree, if the node is the node corresponding to the built-in function, determining the constant character string to be confused selected in the built-in function for the node.
3. The method according to any one of claims 1-2, wherein the method further comprises:
after the constant character strings to be confused are determined, adding marks to be confused to the constant character strings to be confused;
and performing confusion processing on the target constant character string, wherein the confusion processing comprises the following steps:
and carrying out confusion processing on the constant character strings with the marks to be confused.
4. The method according to any of claims 1-2, wherein a pre-configured macro-function is included in a header file of the source code file, the macro-function being used to define the built-in function.
5. The method of claim 1, wherein said obfuscating the target constant string comprises:
encrypting the target constant character string by using a secret key to obtain ciphertext information;
and replacing the target constant character string with the ciphertext information.
6. A code obfuscation apparatus, comprising:
the acquisition module is used for acquiring a source code file of a target application program, wherein the source code file comprises a preset built-in function, and the built-in function is used for selecting constant character strings to be confused in the source code file;
the determining module is used for determining the constant character strings to be confused selected in the built-in function as target constant character strings in the process of compiling the source code file; wherein the determining the constant character string to be confused selected in the built-in function further comprises: if the type of the parameter of the built-in function is a constant expression, determining a target operand from a representation form corresponding to the constant expression of the parameter; if the type of the target operand is a global variable, determining a constant character string from a representation form corresponding to the global variable of the target operand, wherein the constant character string is used as a constant character string to be confused;
And the confusion module is used for carrying out confusion processing on the target constant character string.
7. An electronic device, comprising:
one or more processors;
a memory;
one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more applications configured to: a code obfuscation method according to any of claims 1-5 is performed.
8. A computer readable medium having stored thereon a computer program, characterized in that the program, when executed by a processor, implements the code obfuscation method according to any of claims 1-5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011141687.2A CN112256275B (en) | 2020-10-22 | 2020-10-22 | Code confusion method, device, electronic equipment and medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011141687.2A CN112256275B (en) | 2020-10-22 | 2020-10-22 | Code confusion method, device, electronic equipment and medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112256275A CN112256275A (en) | 2021-01-22 |
| CN112256275B true CN112256275B (en) | 2023-09-29 |
Family
ID=74263283
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011141687.2A Active CN112256275B (en) | 2020-10-22 | 2020-10-22 | Code confusion method, device, electronic equipment and medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112256275B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113434148B (en) * | 2021-06-30 | 2024-03-22 | 广东迅维信息产业股份有限公司 | Decryption-preventing client development compiling method and device, electronic equipment and storage medium |
| CN115906014A (en) * | 2021-08-13 | 2023-04-04 | 华为技术有限公司 | Data processing method and related device |
| CN115048623A (en) * | 2022-04-01 | 2022-09-13 | 上海任意门科技有限公司 | Method, computing device and storage medium for encrypting code |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106326693A (en) * | 2016-08-18 | 2017-01-11 | 广州优视网络科技有限公司 | Obfuscation method and obfuscation device for application program code |
| CN110059455A (en) * | 2019-04-09 | 2019-07-26 | 北京迈格威科技有限公司 | Code encryption method, apparatus, electronic equipment and computer readable storage medium |
| CN110598379A (en) * | 2019-09-23 | 2019-12-20 | 北京智游网安科技有限公司 | Method, system, equipment and storage medium for implementing character string confusion |
-
2020
- 2020-10-22 CN CN202011141687.2A patent/CN112256275B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106326693A (en) * | 2016-08-18 | 2017-01-11 | 广州优视网络科技有限公司 | Obfuscation method and obfuscation device for application program code |
| CN110059455A (en) * | 2019-04-09 | 2019-07-26 | 北京迈格威科技有限公司 | Code encryption method, apparatus, electronic equipment and computer readable storage medium |
| CN110598379A (en) * | 2019-09-23 | 2019-12-20 | 北京智游网安科技有限公司 | Method, system, equipment and storage medium for implementing character string confusion |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112256275A (en) | 2021-01-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11520912B2 (en) | Methods, media, apparatuses and computing devices of user data authorization based on blockchain | |
| CN112256275B (en) | Code confusion method, device, electronic equipment and medium | |
| US10218790B2 (en) | Providing access to a resource for a computer from within a restricted network | |
| CN108399318B (en) | Executable file generation method, executable file execution method and electronic equipment | |
| CN110008662B (en) | Application program running method and device, electronic equipment and readable storage medium | |
| CN109613990A (en) | Soft keyboard secured inputting method, server, client, electronic equipment and medium | |
| CN107103211A (en) | SDK is sent, using issue, using operation method and device | |
| CN111309304B (en) | Method, device, medium and electronic equipment for generating IDL file | |
| CN111245811A (en) | Information encryption method and device and electronic equipment | |
| CN109739582B (en) | Function calling method and device, electronic equipment and computer readable storage medium | |
| CN108459852A (en) | Script processing method and device, storage medium, electronic equipment | |
| CN112416303B (en) | Software development kit hot repair method and device and electronic equipment | |
| CN111666218B (en) | Code auditing method, device, electronic equipment and medium | |
| CN111124541B (en) | Configuration file generation method, device, equipment and medium | |
| CN110765238A (en) | Data encryption query method and device | |
| CN114154123B (en) | Encryption protection method applied to Python project | |
| CN111274551B (en) | Compiler-based java code protection method and device and electronic equipment | |
| CN114491421A (en) | File encryption method, file processing method, file encryption device, file processing device, readable medium and electronic equipment | |
| CN113391811B (en) | Function compiling method, function compiling device, electronic equipment and computer readable storage medium | |
| CN111143355B (en) | Data processing method and device | |
| CN109657480A (en) | A kind of document handling method, equipment and computer readable storage medium | |
| CN113742774B (en) | Data processing method and device, readable medium and electronic equipment | |
| CN113032808B (en) | Data processing method and device, readable medium and electronic equipment | |
| CN110492998A (en) | The method of encryption and decryption data | |
| CN110543772A (en) | Offline decryption method and device |
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 | ||
| CB02 | Change of applicant information | ||
| CB02 | Change of applicant information |
Address after: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant after: Douyin Vision Co.,Ltd. Address before: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant before: Tiktok vision (Beijing) Co.,Ltd. Address after: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant after: Tiktok vision (Beijing) Co.,Ltd. Address before: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant before: BEIJING BYTEDANCE NETWORK TECHNOLOGY Co.,Ltd. |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant |