CN111832014B - Java SDK code encryption and decryption method and terminal based on dynamic loading - Google Patents
Java SDK code encryption and decryption method and terminal based on dynamic loading Download PDFInfo
- Publication number
- CN111832014B CN111832014B CN202010625106.6A CN202010625106A CN111832014B CN 111832014 B CN111832014 B CN 111832014B CN 202010625106 A CN202010625106 A CN 202010625106A CN 111832014 B CN111832014 B CN 111832014B
- Authority
- CN
- China
- Prior art keywords
- jar
- sdk
- code
- file
- encrypted
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 48
- 230000006870 function Effects 0.000 claims abstract description 56
- 230000008569 process Effects 0.000 claims abstract description 8
- 238000010586 diagram Methods 0.000 description 7
- 230000006835 compression Effects 0.000 description 2
- 238000007906 compression Methods 0.000 description 2
- 239000004973 liquid crystal related substance Substances 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 238000004883 computer application Methods 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 230000000007 visual effect Effects 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/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/52—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity ; Preventing unwanted data erasure; Buffer overflow
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2221/00—Indexing scheme relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F2221/21—Indexing scheme relating to G06F21/00 and subgroups addressing additional information or applications relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F2221/2107—File encryption
Landscapes
- Engineering & Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Storage Device Security (AREA)
Abstract
The invention discloses a Java SDK code encryption and decryption method and a terminal based on dynamic loading, wherein the method comprises the following steps: analyzing class files in the Jar package, and converting the functions into code-free interface functions; encrypting and hiding the Jar packet; after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar; putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar; starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process; the decryption engine Jar decrypts and loads codes in the decrypted Jar into the memory by using the main class loader, and the application normally calls the codes of the decrypted SDK, so that the code security of the SDK is effectively protected.
Description
Technical Field
The invention relates to the technical field of computer application, in particular to a Java SDK code encryption and decryption method and a terminal based on dynamic loading.
Background
Java is an object-oriented programming language, not only absorbs various advantages of the C++ language, but also abandons concepts such as multiple inheritance and pointers which are difficult to understand in the C++, so that the Java language has two characteristics of powerful functions, simplicity and easiness in use; the Java language is used as a representative of a static object-oriented programming language, so that the object-oriented theory is well realized, and a programmer is allowed to carry out complex programming in an elegant thinking mode; java has the characteristics of simplicity, object-oriented, distributed, robustness, security, platform independence and portability, multithreading, dynamics and the like.
Jar is a Java (computer programming language) package file format that is commonly used to aggregate large numbers of Java bytecode files. The SDK (Software Development Kit, software development kit, generally a collection of development tools for a particular software package, software framework, hardware platform, operating system, etc. when some software engineers build application software) code of Java refers to the Jar file. Common SDKs include advertising, payment, etc., which face a double threat from third party hackers and developers of integrated SDKs, code protection for Java SDKs is becoming more and more important.
However, in the prior art, an effective means is lacking for protecting the code of the Java SDK, the SDK code is easy to be exposed to an SDK integrator and an application user, and the code security of the SDK cannot be effectively protected.
Accordingly, the prior art is still in need of improvement and development.
Disclosure of Invention
The invention mainly aims to provide a Java SDK code encryption and decryption method and a terminal based on dynamic loading, and aims to solve the problem that the code security of an SDK cannot be effectively protected in the prior art.
In order to achieve the above purpose, the present invention provides a Java SDK code encryption and decryption method based on dynamic loading, which comprises the following steps:
analyzing a class file in a Jar package, and converting a function in the class file into a code-free interface function;
encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file;
after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar;
putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar;
starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process;
the decryption engine Jar decrypts and loads the codes in the decrypted Jar into the memory by using the main class loader, and the decrypted codes of the SDK are normally invoked by the application.
Optionally, the dynamically loaded Java SDK code encryption and decryption method, wherein the converting the function in the class file into a code-free interface function specifically includes:
according to the binary file structure of the byte code file, analyzing each class file in the Jar package;
and acquiring code segments of all functions in each class file, deleting binary code instructions stored in the code segments, and converting the functions in each class file into code-free interface functions.
Optionally, in the method for encrypting and decrypting the Java SDK code based on dynamic loading, the interface function has no code and only has function declaration.
Optionally, the method for encrypting and decrypting the Java SDK code based on dynamic loading, wherein analyzing the class file in the Jar packet further includes:
if the SDK is in the Android AAR format, jar packets need to be decompressed from the AAR.
Optionally, in the method for encrypting and decrypting the Java SDK code based on dynamic loading, if the Java package is an Android platform, the Jar package is converted into a DEX file of an Android system and then encrypted, which specifically includes:
if the Android package is the Jar package of the Android platform, a class file in the Jar package needs to be converted into a DEX file in a DEX format supported by the Android Dalvik virtual machine by using a Dx tool.
Optionally, in the method for encrypting and decrypting the Java SDK code based on dynamic loading, the interface function is used for referring to the code in the SDK when the developer integrates the SDK, and the code is not compiled into the application.
In addition, to achieve the above object, the present invention also provides a terminal, wherein the terminal includes: the Java SDK code encryption and decryption method based on dynamic loading comprises the steps of a memory, a processor and a Java SDK code encryption and decryption program based on dynamic loading, wherein the Java SDK code encryption and decryption program based on dynamic loading is stored in the memory and can run on the processor, and the Java SDK code encryption and decryption method based on dynamic loading is realized when the Java SDK code encryption and decryption program based on dynamic loading is executed by the processor.
In addition, in order to achieve the above object, the present invention further provides a storage medium, where the storage medium stores a Java SDK code encryption and decryption program based on dynamic loading, and the steps of the Java SDK code encryption and decryption method based on dynamic loading described above are implemented when the Java SDK code encryption and decryption program based on dynamic loading is executed by a processor.
The method converts functions in the class file into code-free interface functions by analyzing the class file in the Jar package; encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file; after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar; putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar; starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process; the decryption engine Jar decrypts and loads the codes in the decrypted Jar into the memory by using the main class loader, and the decrypted codes of the SDK are normally invoked by the application. According to the invention, the function in the Jar package is converted into the code-free interface function by analyzing the class file in the Jar package, the original Jar package is encrypted and hidden, the converted SDK interface file is only used for referencing codes in the SDK when a developer integrates the SDK, the codes are not compiled into an application, the application integrating the encrypted SDK is operated, a main class loader of the current application is obtained, then the encrypted SDK codes are dynamically loaded by using the main class loader, the loading work of the encrypted SDK is completed, the SDK codes are not exposed to an SDK integrator and an application user, and the code safety of the SDK is effectively protected.
Drawings
FIG. 1 is a flow chart of a preferred embodiment of the dynamic loading based Java SDK code encryption and decryption method of the present invention;
FIG. 2 is a schematic diagram of an encryption flow in a preferred embodiment of the Java SDK code encryption and decryption method based on dynamic loading of the present invention;
FIG. 3 is a schematic diagram of a decryption flow run in a preferred embodiment of the Java SDK code encryption and decryption method based on dynamic loading of the present invention;
FIG. 4 is a schematic diagram of the Jar file structure in the preferred embodiment of the Java SDK code encryption and decryption method based on dynamic loading in the invention;
FIG. 5 is a schematic diagram of a class file structure in a preferred embodiment of the dynamic loading-based Java SDK code encryption and decryption method of the present invention;
FIG. 6 is a diagram of AAR file structure in a preferred embodiment of the dynamic loading-based Java SDK code encryption and decryption method of the present invention;
FIG. 7 is a schematic diagram of the operating environment of a preferred embodiment of the terminal of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more clear and clear, the present invention will be further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
The Java SDK code encryption and decryption method based on dynamic loading according to the preferred embodiment of the invention, as shown in figures 1, 2 and 3, comprises the following steps:
s10, analyzing a class file in a Jar package, and converting a function in the class file into a code-free interface function;
specifically, an original Jar package is copied, class files (may be multiple class files, such as a.class, b.class, and c.class in fig. 2) in the Jar package are parsed, and functions therein are converted into code-free interface functions. If the SDK is in the Android AAR format, jar needs to be decompressed from the AAR first and then encryption operation is carried out, as shown in fig. 6, the AAR is in the SDK format of the Android platform, the AAR is also a zip compression package, and the code class. Jar of the SDK is stored in the zip compression package, and some additional resource files can be directly decompressed to obtain class. Jar, so that the class. Jar is encrypted and protected.
Among them, in the software field, jar files (Java Archive, english: java Archive) are a software package file format, which is generally used to aggregate a large number of Java class files, related metadata and resource (text, picture, etc.) files into one file, so as to develop Java platform application software or libraries, as shown in fig. 4.
The class file is named as Java class file, so that Java is more suitable for a network mainly in the aspects of platform independence and network mobility, and the task of the Java in the aspects of platform independence is as follows: the Java program is provided with a binary-form service independent of the underlying host platform, as shown in fig. 5, which shows a schematic diagram of the class file structure.
Wherein, the Java code needs to be compiled into binary files of class byte codes so as to be executed by the Java virtual machine. The Jar package is a compressed file in a zip format, a plurality of class byte code files are stored in the compressed file, each class file corresponds to a java source code file, and the real binary instruction of function codes stored in the class files in the Jar package is to be encrypted and protected.
The interface function for converting the function in the class file into the code-free interface function is specifically: according to the binary file structure of the byte code file, analyzing each class file in the Jar package, acquiring code segments of all functions in each class file, deleting binary code instructions stored in the code segments, and converting the functions in each class file into code-free interface functions, wherein the interface functions have no codes and only have function declarations.
And S20, encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file.
Specifically, the original Jar package is encrypted and hidden, and if the original Jar package is a Jar package of an Android platform, a class file in the Jar package needs to be converted into a DEX file in a DEX format supported by an Android Dalvik virtual machine by using a Dx tool (or a D8 tool).
For example, the Android platform decompresses and acquires class.jar from the SDK format file such as AAR, and encrypts the class file in the class.jar.
Because the Dalvik virtual machine of the Android system and the common Java virtual machine support executable file formats are different, an Android official Dx tool needs to be called to convert a class file in Jar into a DEX file (the DEX file is an executable file of the Android system and contains all operation instructions and runtime data of an application program).
After the java program is compiled into class, all class files are integrated into one DEX file by using a DEX tool, so that each class can share data, redundancy is reduced to a certain extent, meanwhile, the file structure is more compact, and the DEX file is about 50% of the size of a traditional Jar file; DEX integrates the common information of each file of the original class, thus reducing the redundancy of the class.
Step S30, after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar.
Specifically, as shown in fig. 2, the encrypted output is completed, including the interface Jar, the decryption engine Jar, and the encrypted Jar.
And S40, taking the encrypted Jar as a resource file, putting the resource file into an application source code project, introducing the interface Jar and the decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar.
Specifically, the application integration uses the encrypted SDK, and needs to put the encrypted Jar as a resource file into an application source code project, introduce the interface Jar and the decryption engine Jar into the project, and initialize and call the decryption engine Jar before using the encrypted Jar.
And step S50, starting the application integrated with the encrypted SDK, and starting a decryption engine Jar when running to acquire a main class loader of the current process.
Specifically, an application integrating an encrypted SDK is started, and a decryption engine Jar started first at the time of running; the decryption engine is started to obtain a main class loader of the current process. The method comprises the steps that various information described in a Class file can be operated and used after being finally loaded into a virtual machine, the virtual machine loads data describing classes from the Class file into a memory, and the data are verified, converted, analyzed and initialized to finally form java types which can be directly used by the virtual machine, and the java types are Class loading mechanisms of the virtual machine.
The encrypted SDK is ultimately intended for use by other development engineers who integrate the SDK into their own engineering projects, using the functionality provided by the SDK.
And step S60, the decryption engine Jar decrypts and loads codes in the decrypted Jar into the memory by using the main class loader, and the codes of the decrypted SDK are normally called by the application.
Specifically, the decryption engine decrypts and loads the encrypted Jar into memory using the main class loader. The application normally invokes the code in the encrypted Jar that the decryption engine loads.
According to the code encryption method provided by the invention, firstly, the class file in the Jar is analyzed, the function in the Jar is converted into the code-free interface function, and in addition, the original Jar is encrypted and hidden (if the Android system operates, jar needs to be converted into a DEX file format executable by an Android platform), wherein the converted SDK interface file is only used for integrating the SDK by a developer, the code in the SDK is referenced, and the code cannot be compiled into the application. In addition, the application integrating the encrypted SDK is operated, firstly, a decryption engine is executed, a main class loader of the current application is obtained, then the encrypted SDK code is dynamically loaded by using the main class loader, the loading work of the encrypted SDK is completed, the SDK code is not exposed to an SDK integrator and an application user, and therefore the code security of the SDK can be effectively protected.
Further, as shown in fig. 6, based on the above method for encrypting and decrypting the Java SDK code based on dynamic loading, the present invention further provides a terminal correspondingly, where the terminal includes a processor 10, a memory 20 and a display 30. Fig. 6 shows only some of the components of the terminal, but it should be understood that not all of the illustrated components are required to be implemented and that more or fewer components may alternatively be implemented.
The memory 20 may in some embodiments be an internal storage unit of the terminal, such as a hard disk or a memory of the terminal. The memory 20 may in other embodiments also be an external storage device of the terminal, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card) or the like, which are provided on the terminal. Further, the memory 20 may also include both an internal storage unit and an external storage device of the terminal. The memory 20 is used for storing application software installed in the terminal and various data, such as program codes of the installation terminal. The memory 20 may also be used to temporarily store data that has been output or is to be output. In an embodiment, the memory 20 stores a Java SDK code encryption and decryption program 40 based on dynamic loading, and the Java SDK code encryption and decryption program 40 based on dynamic loading can be executed by the processor 10, so as to implement the Java SDK code encryption and decryption method based on dynamic loading in the present application.
The processor 10 may be a central processing unit (Central Processing Unit, CPU), microprocessor or other data processing chip in some embodiments, for running the program code or processing data stored in the memory 20, for example, executing the dynamic loading-based Java SDK code encryption and decryption method, etc.
The display 30 may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, an OLED (Organic Light-Emitting Diode) touch, or the like in some embodiments. The display 30 is used for displaying information at the terminal and for displaying a visual user interface. The components 10-30 of the terminal communicate with each other via a system bus.
In one embodiment, the following steps are implemented when the processor 10 executes the Java SDK code encryption and decryption program 40 based on dynamic loading in the memory 20:
analyzing a class file in a Jar package, and converting a function in the class file into a code-free interface function;
encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file;
after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar;
putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar;
starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process;
the decryption engine Jar decrypts and loads the codes in the decrypted Jar into the memory by using the main class loader, and the decrypted codes of the SDK are normally invoked by the application.
The converting the function in the class file into a code-free interface function specifically comprises the following steps:
according to the binary file structure of the byte code file, analyzing each class file in the Jar package;
and acquiring code segments of all functions in each class file, deleting binary code instructions stored in the code segments, and converting the functions in each class file into code-free interface functions.
The interface function has no code and only has function declaration.
The analyzing the class file in the Jar package further comprises:
if the SDK is in the Android AAR format, jar packets need to be decompressed from the AAR.
If the Android package is the Jar package of the Android platform, the Jar package is converted into a DEX file of the Android system and then encrypted, and the method specifically comprises the following steps:
if the Android package is the Jar package of the Android platform, a class file in the Jar package needs to be converted into a DEX file in a DEX format supported by the Android Dalvik virtual machine by using a Dx tool.
The interface function is used for referencing codes in the SDK when a developer integrates the SDK, and is not compiled into an application.
The invention also provides a storage medium, wherein the storage medium stores a Java SDK code encryption and decryption program based on dynamic loading, and the Java SDK code encryption and decryption program based on dynamic loading realizes the steps of the Java SDK code encryption and decryption method based on dynamic loading when being executed by a processor.
In summary, the invention provides a Java SDK code encryption and decryption method and a terminal based on dynamic loading, wherein the method comprises the following steps: analyzing a class file in a Jar package, and converting a function in the class file into a code-free interface function; encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file; after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar; putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar; starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process; the decryption engine Jar decrypts and loads the codes in the decrypted Jar into the memory by using the main class loader, and the decrypted codes of the SDK are normally invoked by the application. According to the invention, the function in the Jar package is converted into the code-free interface function by analyzing the class file in the Jar package, the original Jar package is encrypted and hidden, the converted SDK interface file is only used for referencing codes in the SDK when a developer integrates the SDK, the codes are not compiled into an application, the application integrating the encrypted SDK is operated, a main class loader of the current application is obtained, then the encrypted SDK codes are dynamically loaded by using the main class loader, the loading work of the encrypted SDK is completed, the SDK codes are not exposed to an SDK integrator and an application user, and the code safety of the SDK is effectively protected.
Of course, those skilled in the art will appreciate that implementing all or part of the above-described methods may be implemented by a computer program for instructing relevant hardware (such as a processor, a controller, etc.), where the program may be stored in a computer-readable storage medium, and where the program may include the steps of the above-described method embodiments when executed. The storage medium may be a memory, a magnetic disk, an optical disk, or the like.
It is to be understood that the invention is not limited in its application to the examples described above, but is capable of modification and variation in light of the above teachings by those skilled in the art, and that all such modifications and variations are intended to be included within the scope of the appended claims.
Claims (4)
1. The Java SDK code encryption and decryption method based on dynamic loading is characterized by comprising the following steps of:
analyzing a class file in a Jar package, and converting a function in the class file into a code-free interface function;
the converting the function in the class file into a code-free interface function specifically comprises the following steps:
according to the binary file structure of the byte code file, analyzing each class file in the Jar package;
acquiring code segments of all functions in each class file, deleting binary code instructions stored in the code segments, and converting the functions in each class file into code-free interface functions;
the analyzing the class file in the Jar package further comprises:
if the SDK is in the Android AAR format, the Jar packet is needed to be decompressed from the AAR and then encryption operation is carried out;
encrypting and hiding the Jar package, and if the Jar package is of an Android platform, converting the Jar package into a DEX file of an Android system and encrypting the DEX file;
if the Android package is the Jar package of the Android platform, the Jar package is converted into a DEX file of the Android system and then encrypted, and the method specifically comprises the following steps:
if the file is a Jar packet of an Android platform, converting a class file in the Jar packet into a DEX file in a DEX format supported by an Android Dalvik virtual machine by using a Dx tool, wherein the DEX integrates common information of each file of the original class, so that redundancy of the class is reduced;
after the encryption operation is completed, outputting an interface Jar, a decryption engine Jar and the encrypted Jar;
putting the encrypted Jar as a resource file into an application source code project, introducing an interface Jar and a decryption engine Jar into the project, and initializing and calling the decryption engine Jar before using the encrypted Jar;
starting an application integrated with the encryption SDK, and starting a decryption engine Jar when running to obtain a main class loader of the current process;
the decryption engine Jar decrypts and loads codes in the decrypted Jar into a memory by using a main class loader, and normally invokes the codes of the decrypted SDK;
running an application integrating the encrypted SDK, executing a decryption engine, acquiring a main class loader of the current application, dynamically loading encrypted SDK codes by using the main class loader, completing the loading work of the encrypted SDK, and not exposing the SDK codes to an SDK integrator and an application user, thereby effectively protecting the code security of the SDK;
the interface function is used for referencing codes in the SDK when a developer integrates the SDK, and is not compiled into an application.
2. The method for encrypting and decrypting Java SDK code based on dynamic loading according to claim 1, wherein no code exists in the interface function, and only a function is declared.
3. A terminal, the terminal comprising: the method comprises the steps of a dynamic loading-based Java SDK code encryption and decryption method according to any one of claims 1-2, wherein the dynamic loading-based Java SDK code encryption and decryption program is stored in a memory and can run on the processor.
4. A storage medium, wherein the storage medium stores a Java SDK code encryption/decryption program based on dynamic loading, and the steps of the Java SDK code encryption/decryption method based on dynamic loading according to any one of claims 1-2 are implemented when the Java SDK code encryption/decryption program based on dynamic loading is executed by a processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010625106.6A CN111832014B (en) | 2020-07-02 | 2020-07-02 | Java SDK code encryption and decryption method and terminal based on dynamic loading |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010625106.6A CN111832014B (en) | 2020-07-02 | 2020-07-02 | Java SDK code encryption and decryption method and terminal based on dynamic loading |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111832014A CN111832014A (en) | 2020-10-27 |
| CN111832014B true CN111832014B (en) | 2024-02-13 |
Family
ID=72900760
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010625106.6A Active CN111832014B (en) | 2020-07-02 | 2020-07-02 | Java SDK code encryption and decryption method and terminal based on dynamic loading |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111832014B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112764827B (en) * | 2020-12-31 | 2023-04-07 | 重庆广播电视大学重庆工商职业学院 | Java class hot loading method with safety verification |
| CN113076146B (en) * | 2021-03-09 | 2024-06-07 | 北京一亩田新农网络科技有限公司 | Dynamic APK loading method, device, system and medium |
| CN113489723B (en) * | 2021-07-05 | 2022-11-22 | 平安科技（深圳）有限公司 | Data transmission method, system, computer device and storage medium |
| CN114924809B (en) * | 2022-05-19 | 2024-03-29 | 西安理工大学 | DEX file class-based streaming micro-service loading verification method |
| CN116126427B (en) * | 2023-04-14 | 2023-07-18 | 杭州比智科技有限公司 | Implementation method of non-invasive SDK auxiliary integrated plug-in based on tangent plane programming |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101944042A (en) * | 2010-09-01 | 2011-01-12 | 深圳市拜特科技股份有限公司 | Operation method of Java program and electronic terminal |
| CN107220529A (en) * | 2017-05-19 | 2017-09-29 | 湖南鼎源蓝剑信息科技有限公司 | A kind of reinforcement means for Android platform SDK bags |
| KR20180015535A (en) * | 2016-08-03 | 2018-02-13 | 주식회사 엔에스에이치씨 | Obfuscation method of android application using partial encryption of dex file in android application package |
| CN108491235A (en) * | 2018-03-21 | 2018-09-04 | 北京理工大学 | In conjunction with the DEX guard methods of dynamic load and function Nativeization |
-
2020
- 2020-07-02 CN CN202010625106.6A patent/CN111832014B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101944042A (en) * | 2010-09-01 | 2011-01-12 | 深圳市拜特科技股份有限公司 | Operation method of Java program and electronic terminal |
| KR20180015535A (en) * | 2016-08-03 | 2018-02-13 | 주식회사 엔에스에이치씨 | Obfuscation method of android application using partial encryption of dex file in android application package |
| CN107220529A (en) * | 2017-05-19 | 2017-09-29 | 湖南鼎源蓝剑信息科技有限公司 | A kind of reinforcement means for Android platform SDK bags |
| CN108491235A (en) * | 2018-03-21 | 2018-09-04 | 北京理工大学 | In conjunction with the DEX guard methods of dynamic load and function Nativeization |
Non-Patent Citations (3)
| Title |
|---|
| "Android中的ClassLoader与dex文件加密实现分析";阿里安;《https://blog.csdn.net/working_harder/article/details/53213562》;第2-4页 * |
| "Dex加密(上)";追寻米K;《https://www.jianshu.com/p/b5dc99450e20》;第1-3页 * |
| 陈锐 等.《Java程序设计》.2012,第6页. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111832014A (en) | 2020-10-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111832014B (en) | Java SDK code encryption and decryption method and terminal based on dynamic loading | |
| CN108932406B (en) | Virtualization software protection method and device | |
| TWI648648B (en) | Protection method of executable program on android platform | |
| US11748468B2 (en) | Dynamic switching between pointer authentication regimes | |
| CN102043932B (en) | Method for preventing Java program from being decompiled | |
| US7685596B1 (en) | Deploying and distributing of applications and software components | |
| US20160203087A1 (en) | Method for providing security for common intermediate language-based program | |
| CN103413076B (en) | A kind of Android application program divides the method for block protection | |
| CN103914637B (en) | A kind of executable program encryption method of Android platform | |
| WO2016078130A1 (en) | Dynamic loading method for preventing reverse of apk file | |
| EP3296906A1 (en) | Method for protecting dex file from being decompiled in android system | |
| CN110059456B (en) | Code protection method, code protection device, storage medium and electronic equipment | |
| US20090138863A1 (en) | Method And Apparatus For Protecting .NET Programs | |
| CN104573416A (en) | Method and device for generating application installation package and executing application | |
| US20020112158A1 (en) | Executable file protection | |
| CN100492387C (en) | Method and system for software protected development based on Keil C51 | |
| CN112052433B (en) | Virtual protection method, terminal and storage medium for Jar file | |
| CN110609687A (en) | Compiling method, device, electronic equipment and storage medium | |
| CN107871066B (en) | Code compiling method and device based on android system | |
| CN112559980B (en) | Applet runtime capable of embedding a plurality of random APP | |
| CN112052461A (en) | Code processing method based on instruction injection, terminal and storage medium | |
| CN111381816A (en) | Application program acquisition method, device, equipment and storage medium | |
| US20220308991A1 (en) | Test processing method and information processing apparatus | |
| KR101436741B1 (en) | The method and system for applying security solution program | |
| US11550883B2 (en) | Code protection |
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 |