Obfuscation implementation method, and recording medium and device for performing same

The method addresses the vulnerability of Android applications to deobfuscation attacks by separating and hiding application code and screen elements, creating a robust obfuscation mechanism that protects personal information from both static and dynamic analysis.

WO2025009679A1PCT designated stage expired Publication Date: 2025-01-09FOUND OF SOONGSIL UNIV IND COOP

Patent Information

Application Number
PCT/KR2023/021413
Authority / Receiving Office
WO · WO
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-07-06
Filing Date
2023-12-22
Publication Date
2025-01-09

AI Technical Summary

Technical Problem

Existing obfuscation technologies for Android applications are vulnerable to deobfuscation attacks through both static and dynamic analysis, failing to effectively protect personal information from unauthorized access.

Method used

The method involves separating and storing application code on an external server, performing static contamination analysis to identify data leakage points, converting code into sensitive and user-defined dex files, hiding strings in a data storage space, and protecting screen elements using various obfuscation techniques to create a hidden Android application package (APK) file, thereby preventing deobfuscation attacks.

Benefits of technology

This approach enhances security by preventing deobfuscation attacks through both static and dynamic analysis, providing a stronger obfuscation effect than existing methods by externally storing code, hiding sensitive data, and protecting screen elements, thus effectively safeguarding personal information.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure KR2023021413_09012025_PF_FP_ABST
    Figure KR2023021413_09012025_PF_FP_ABST
Patent Text Reader

Abstract

The present invention relates to an obfuscation implementation method in an obfuscation implementation device for preventing a deobfuscation attack on an application of an Android terminal, comprising the steps of: separating at least a portion of a code included in an application and storing the separated code in an external server, and hiding a string corresponding to the separated code in a data storage space prepared in advance; and protecting a screen element of an Android terminal. Due to this feature, it is possible to prevent a deobfuscation attack on an application by an attacker through dynamic analysis as well as static analysis of an Android application.
Need to check novelty before this filing date? Find Prior Art

Description

Methods for implementing obfuscation, recording media and devices for performing the same

[0001] The present invention relates to an obfuscation implementation method for preventing a reverse obfuscation attack on an application of an Android terminal, a recording medium and a device for performing the same.

[0002] As mobile device usage increases, so do security threats. In particular, various security issues, such as personal information leaks, continue to arise in Android applications.

[0003] Research is underway to obfuscate application code to address security concerns. Specifically, obfuscation techniques are methods that make it difficult for attackers or unauthorized accessors to understand or modify software source code. In other words, obfuscation techniques reduce the readability of source code while preserving its structure and logic.

[0004] Among these obfuscation techniques, the most representative methods include techniques such as modifying or hiding the source code through code obfuscation and application self-obfuscation to defend against reverse obfuscation attacks such as decompilation or debugging.

[0005] However, as obfuscation technology advances, deobfuscation technologies that utilize static or dynamic analysis of applications are also rapidly developing, making existing obfuscation technologies vulnerable to deobfuscation attacks.

[0006] Therefore, a new obfuscation technique is needed to protect personal information from existing deobfuscation techniques.

[0007] [Prior Art Literature]

[0008] [Patent Document]

[0009] (Patent Document 1) Korean Patent Publication No. 10-1234591

[0010] The present invention has been devised to solve the above problems, and the purpose of the present invention is to provide an obfuscation implementation method capable of preventing an attacker's reverse obfuscation attack on an application through static analysis as well as dynamic analysis of an Android application, and a recording medium and device for performing the same.

[0011] In order to achieve the above object, according to one embodiment of the present invention, a method for implementing obfuscation in an obfuscation implementation device for preventing a reverse obfuscation attack on an application of an Android terminal comprises the steps of: separating at least a portion of the code included in the application and storing it in an external server, and hiding a string corresponding to the separated code in a pre-provisioned data storage space; and protecting a screen element of the Android terminal.

[0012] And separating the above code is to perform a static contamination analysis on the above application to identify data that may be subject to data leakage, and the data that may be subject to data leakage may have a flow that starts from a source, which is the entry point of the static contamination analysis, to a sink through which the data flows out.

[0013] In addition, the file of the above code is a file with the extension dex, and separating the code may be separating the dex file of the code corresponding to the identified data into an SC (sensitive) dex file, a UDC (User Define Class) dex file, and a Classes dex file.

[0014] And in the hiding step, the string is extracted from the file of the separated code, the location where the extracted string is to be inserted in the data storage space is determined, the extracted string is inserted into the data storage space, repackaged, and then signed using a signature, thereby generating an Android application package (APK) file in which the string is hidden.

[0015] Additionally, in the step of protecting the above screen element, the screen element, which is information output through the screen, can be changed using at least one of a plurality of pre-prepared obfuscation techniques.

[0016] Meanwhile, a recording medium according to one embodiment of the present invention for achieving the above purpose is a computer-readable recording medium having recorded thereon a computer program for performing an obfuscation implementation method according to one embodiment of the present invention.

[0017] Meanwhile, an obfuscation implementation device for preventing a reverse obfuscation attack on an application of an Android terminal according to one embodiment of the present invention for achieving the above object may include a code separation unit that separates at least a portion of the code included in the application and stores it in an external server; a hiding unit that hides a string corresponding to the separated code in a pre-provisioned data storage space; and a screen protection unit that protects a screen element of the Android terminal.

[0018] And the above code separation unit separates the code by performing static contamination analysis on the application to identify data with a possibility of data leakage, and the data with a possibility of data leakage may have a flow starting from a source, which is an entry point of the static contamination analysis, to a sink through which data flows out.

[0019] In addition, the file of the above code is a file with the extension dex, and the code separation unit can separate the dex file of the code corresponding to the identified data into an SC (sensitive) dex file, a UDC (User Define Class) dex file, and a Classes dex file.

[0020] And the hidden unit extracts the string from the file of the separated code, determines the location where the extracted string is to be inserted within the data storage space, inserts the extracted string into the data storage space, repackages it, and then signs it using a signature, thereby generating an Android application package (APK) file in which the string is hidden.

[0021] Additionally, the screen protector can change a screen element, which is information output through the screen, by using at least one of a plurality of pre-prepared obfuscation techniques.

[0022] According to one aspect of the present invention described above, by providing a method for implementing obfuscation, a recording medium for performing the same, and a device, it is possible to prevent an attacker's de-obfuscation attack on an application through dynamic analysis as well as static analysis of an Android application.

[0023] FIG. 1 is a block diagram illustrating the configuration of an obfuscation implementation device according to one embodiment of the present invention;

[0024] FIG. 2 is a drawing for explaining an obfuscation implementation process performed by an obfuscation implementation device according to one embodiment of the present invention;

[0025] FIG. 3 is a drawing for explaining the overall process of separating a code by a code separating unit according to one embodiment of the present invention;

[0026] FIG. 4 is a drawing for explaining static contamination analysis performed by a code separation unit according to one embodiment of the present invention.

[0027] FIG. 5 is an exemplary diagram illustrating a process of identifying data to separate codes by a code separation unit according to one embodiment of the present invention;

[0028] FIG. 6 is a drawing for explaining a specific process of separating a code by a code separating unit according to one embodiment of the present invention;

[0029] FIGS. 7 to 9 are exemplary diagrams illustrating various obfuscation techniques used by a screen protector according to one embodiment of the present invention to protect screen elements.

[0030] FIG. 10 is a diagram illustrating the overall process of hiding data in a hidden section according to one embodiment of the present invention.

[0031] Figures 11 to 14 are drawings for explaining the results of hiding data by a hidden unit according to one embodiment of the present invention.

[0032] FIG. 15 is a flowchart for explaining an obfuscation implementation method performed by an obfuscation implementation device according to one embodiment of the present invention; and

[0033] Figure 16 is a graph showing experimental results to explain the effectiveness of an obfuscation implementation method according to one embodiment of the present invention.

[0034] The following detailed description of the present invention refers to the accompanying drawings, which illustrate specific embodiments in which the present invention may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice the present invention. It should be understood that the various embodiments of the present invention, while different from each other, are not necessarily mutually exclusive. For example, specific shapes, structures, and characteristics described herein may be implemented in other embodiments without departing from the spirit and scope of the present invention. Furthermore, it should be understood that the positions or arrangements of individual components within each disclosed embodiment may be modified without departing from the spirit and scope of the present invention. Accordingly, the following detailed description is not intended to be limiting, and the scope of the present invention is defined only by the appended claims, along with the full scope of equivalents to which such claims are entitled, if properly described. Like reference numerals in the drawings designate the same or similar functionality throughout the several aspects.

[0035] The components according to the present invention are defined by functional distinctions rather than physical distinctions, and can be defined by the functions each component performs. Each component may be implemented as hardware or program code and processing units that perform each function, and the functions of two or more components may be implemented by including them in a single component. Therefore, the names given to the components in the following embodiments are not intended to physically distinguish each component, but rather to suggest the representative functions performed by each component, and it should be noted that the technical spirit of the present invention is not limited by the names of the components.

[0036] Hereinafter, preferred embodiments of the present invention will be described in more detail with reference to the drawings.

[0037] FIG. 1 is a block diagram for explaining the configuration of an obfuscation implementation device (100) according to one embodiment of the present invention, and FIG. 2 is a drawing for explaining an obfuscation implementation process performed in an obfuscation implementation device (100) according to one embodiment of the present invention.

[0038] An obfuscation implementation device (100, hereinafter referred to as device) according to this embodiment is provided to prevent a reverse obfuscation attack on an application of an Android terminal.

[0039] To this end, the device (100) according to the present embodiment may include a communication unit (110), a storage unit (120), and a control unit (130). In addition, the device (100) may be installed and executed with software (application) for performing an obfuscation implementation method, and the communication unit (110), the storage unit (120), and the control unit (130) may be controlled by the software (application) for performing an obfuscation implementation method.

[0040] At this time, the device (100) may be a separate terminal or a module of a terminal. In addition, the configuration of the communication unit (110), storage unit (120), and control unit (130) may be formed as an integrated module or may be composed of one or more modules. However, conversely, each configuration may be composed of a separate module.

[0041] In addition, the device (100) may be mobile or fixed. This device (100) may be in the form of a server or an engine, and may be called by other terms such as a device, an apparatus, a terminal, a UE (user equipment), an MS (mobile station), a wireless device, a handheld device, etc. In addition, the device (100) may execute or produce various software based on an operating system (OS), that is, a system. Here, the operating system is a system program for enabling software to use the hardware of the device, and may include all mobile computer operating systems such as Android OS, iOS, Windows Mobile OS, Bada OS, Symbian OS, and Blackberry OS, as well as computer operating systems such as Windows series, Linux series, Unix series, MAC, AIX, and HP-UX.

[0042] The communication unit (110) of the present invention is provided to transmit or receive information required in the process of implementing obfuscation in the control unit (130) to or from the outside.

[0043] The communication unit (110) can transmit and receive information with an external server, which is a server provided externally. Specifically, the communication unit (110) according to the present embodiment can store at least a portion of the code included in the application in an external server under the control of the control unit (130).

[0044] Additionally, the communication unit (110) may request and receive a code stored in an external server under the control of the control unit (130) and transmit it to the control unit (130).

[0045] Meanwhile, the storage unit (120) records a program for implementing an obfuscation method. Furthermore, the storage unit (120) temporarily or permanently stores data processed by the control unit (130), and may include a volatile or non-volatile storage medium, but the scope of the present invention is not limited thereto.

[0046] And the storage unit (120) stores data accumulated while performing the obfuscation implementation method.

[0047] Meanwhile, a control unit (130) is provided to control the entire process of providing an obfuscation implementation method. This control unit (130) may include a code separation unit (131), a screen protection unit (133), and a concealment unit (135).

[0048] First, the code separation unit (131) can separate at least a portion of the code included in the application and store it on an external server. At this time, the code separation unit (131) can delete the separated code from the Android terminal.

[0049] FIG. 3 is a drawing for explaining the overall process of separating a code by a code separation unit (131) according to one embodiment of the present invention.

[0050] The code separation unit (131) can first perform static contamination analysis on the application to separate the code and identify data that may be susceptible to data leakage.

[0051] FIG. 4 is a drawing for explaining static contamination analysis performed by the code separation unit (131). As shown in FIG. 4, context, flow, field, object detection, and life cycle can be recognized through FlowDroid, which is a vertex contamination analysis tool.

[0052] Data leaks occur when a flow begins at a source, the entry point for the static taint analysis tool FlowDroid, and flows to a sink, where data flows out. In most applications, sensitive user information is leaked through this path, starting from a source and flowing to a sink.

[0053] Accordingly, the code separation unit (131) can detect information leakage through context, flow, field, and object sensitivity by tracing the flow from the source to the sink using the static contamination analysis tool FlowDroid to generate an .xml file and executing static analysis.

[0054] Accordingly, the code separation unit (131) identifies data that has a flow starting from the source, which is the entry point of the static contamination analysis tool FlowDroid, to the sink, where the data flows out, as data with a possibility of data leakage. Fig. 5 is an example diagram illustrating the results of the code separation unit (131) identifying data with a possibility of data leakage through static contamination analysis.

[0055] And the code separation unit (131) can separate the code files corresponding to data identified as having a possibility of data leakage into a predetermined number.

[0056] FIG. 6 is a drawing illustrating a process in which a code separation unit (131) separates a code. As illustrated in FIG. 6, the code separation unit (131) can separate a dex file with an extension of dex into three files as a file of code corresponding to the identified data.

[0057] More specifically, the code separation unit (131) selects a class to be separated, that is, to protect against data identified as having a possibility of leakage.

[0058] At this time, when selecting a class to be separated, there may be cases where there are multiple codes containing important codes. If there are multiple classes to be separated, the code separation unit (131) may select one class based on the number of instructions contained in each of the multiple classes. For example, the code separation unit (131) may ultimately select the class containing the largest number of instructions among the multiple classes as the class to be separated.

[0059] And the code separation unit (131) can separate one dex file corresponding to the selected class into an SC (sensitive Code) dex file, a UDC (User Define Class) dex file, and other Classes dex files.

[0060] And since there is a hidden code in the SC dex file among the separated dex files, the code separation unit (131) can store the SC dex file in an external server.

[0061] After the SC dex file is stored on an external server, a communication process with the external server where the separated code is stored is required to run the application.

[0062] Specifically, on Android devices, applications without separated code do not operate normally, and applications only operate normally when the separated code is called through an external server with the consent of the user (owner of the Android device).

[0063] Even if an attacker performs static analysis on the application through this code separation unit (131), analysis cannot be performed on the code stored on the external server.

[0064] Furthermore, when dynamic analysis is performed, code stored and protected on external servers must be executed. However, this requires the user's consent to execute the code, preventing application analysis from deobfuscation attacks using dynamic analysis.

[0065] Meanwhile, the screen protector (133) protects the screen elements of the Android terminal to prevent deobfuscation by dynamic analysis.

[0066] The screen protector (133) can change a screen element, which is information output through the screen, by using at least one of a plurality of obfuscation techniques prepared in advance.

[0067] Specifically, FIGS. 7 to 9 are exemplary diagrams illustrating various obfuscation techniques used by the screen protector (133) to protect screen elements.

[0068] Specifically, the screen protector (133) according to the present embodiment protects the Android user interface environment from deobfuscation tools. In particular, it can prevent deobfuscation and analysis using dynamic analysis tools such as Android Monkey and Android Automator.

[0069] The obfuscation technique used by the screen protector (133) to change the screen elements may include at least one of a layout addition technique, a linear layout hiding technique, an activity tree graph (hereinafter referred to as ATG) complexity increasing technique, an API hiding technique, an overlay view layout technique, and a screen shot prevention technique.

[0070] The layout addition technique is a method in which the screen protector (133) adds a linear layout and a frame layout to the existing original APK.

[0071] For example, as shown in Fig. 7, the original APK can be seen to have a linear layout and user interface elements including two buttons and a text view.

[0072] When the screen protector (133) changes the screen elements according to the layout addition technique, the screen protector (133) can change the screen elements by adding the Button 1, Button 2, Text 1, and Text 2 image user interfaces to the original APK as shown in FIG. 7 to prevent dynamic analysis.

[0073] Additionally, the screen protector (133) may add a frame layout to interfere with layout analysis.

[0074] And, according to the Screen Shot Prevention technique, the screen protector (133) can prevent screenshots from tools that utilize capture, as illustrated in FIG. 7, by using the flag_secure code to prevent app information theft using snapshots. Accordingly, the screen protector (133) can prevent deobfuscation from dynamic analysis tools that extract application information through screenshots.

[0075] And the screen protector (133) can apply Java reflection by creating an asset manager in the layout file according to the linear layout hiding technique.

[0076] Additionally, the screen protector (133) can use an activity tree graph (hereinafter referred to as ATG) complexity increasing technique.

[0077] When changing screen elements using the ATG complexity increasing technique, the screen protector (133) can expand the ATG by inserting nodes and edges into the ATG.

[0078] And when changing screen elements using the API hiding technique, the screen protector (133) can change the screen elements in a way that applies the API hiding obfuscation technique to the applied codes or prevents ATG-related API identification when dynamically loading after patching.

[0079] Additionally, the screen protector (133) can change screen elements by inserting a dummy code into the activity section.

[0080] And the screen protector (133) can change the screen elements by hiding buttons or text views included in the original APK according to the overlay view layout technique.

[0081] Additionally, the screen protector (133) may modify screen elements by combining two or more of the above-described deobfuscation techniques. For example, as illustrated in FIG. 8, the screen protector (133) may modify screen elements by simultaneously adding an image user interface including multiple buttons to the original APK and using a screenshot prevention technique.

[0082] Figure 9 is a drawing comparing screen elements output before obfuscation and screen elements output after obfuscation by changing screen elements through a screen protector (133).

[0083] Meanwhile, the hidden section (135) is provided to hide a string corresponding to an important code.

[0084] In other words, the hidden part (135) can perform code obfuscation by hiding important data and resources by embedding them in other data, image files, audio files, etc., by taking advantage of the characteristics of the application.

[0085] Figure 10 is a drawing for explaining the overall process of the hiding unit (135) hiding data. The hiding unit (135) hides a string corresponding to a code separated by the code separation unit (131) in a data storage space prepared in advance.

[0086] The hidden unit (135) can extract a string from a file of separated code and determine the location where the extracted string is to be inserted within the data storage space. For example, the extracted string may refer to a string value used in a class selected by the code separation unit (131).

[0087] Figures 11 to 14 are exemplary diagrams for explaining the process and result of the hiding unit (135) hiding data. More specifically, Figure 11 is a diagram showing a Hex value before obfuscation of an application is performed through the hiding unit (135), and Figure 12 is a diagram showing a Hex value after obfuscation of an application is performed through the hiding unit (135). In addition, Figure 13 is a diagram comparing APKs before and after obfuscation of an application is performed through the hiding unit (135), and Figure 14 is an exemplary diagram showing a string output after obfuscation of an application is performed through the hiding unit (135).

[0088] The data storage space where the hidden part (135) inserts the string may be a space located behind the Android image data that can be secured during the Android optimization process, as shown in FIGS. 11 and 12.

[0089] The hidden unit (135) then inserts the extracted string into the identified data storage space, repackages it, and signs it using a signature. The hidden unit (135) signing using a signature may be using the "Encrypted_String" signature, as illustrated in FIG. 12.

[0090] And, by completing the signature, the hidden unit (135) can create an Android application package (APK, Android application Package) file with a hidden string as shown in FIG. 13.

[0091] Therefore, unlike conventional obfuscation techniques that obfuscate a portion of the code or make it difficult to analyze, the hiding part (135) can protect the application code in the form of byte code with low analysis difficulty by storing a string corresponding to the code in a data storage space within the application file structure.

[0092] These hidden strings can be dynamically loaded and executed with the user's consent when the application is launched.

[0093] More specifically, when the application is executed, it can use the "Encrypted" signature to retrieve the hidden string behind the signature, allowing the application to execute normally.

[0094] Through the above configuration, the device (100) according to the present embodiment can provide a more powerful obfuscation effect than existing obfuscation tools by incorporating a code separation technology that stores a part of the code externally, a DSSU (Data Storage Space Utilization) technology that hides a string corresponding to the code stored externally, and a SEP (Screen Element Protection) technology that protects screen elements, thereby hiding classes and data that can be statically and dynamically analyzed inside and outside of an Android terminal.

[0095]

[0096] Meanwhile, FIG. 15 is a flowchart for explaining an obfuscation implementation method performed in an obfuscation implementation device (100) according to one embodiment of the present invention. Since the obfuscation implementation method according to one embodiment of the present invention is performed on a configuration substantially identical to that of the obfuscation implementation device (100) illustrated in FIG. 1, the same components as those of the obfuscation implementation device (100) are given the same drawing reference numerals, and repeated explanations are omitted.

[0097] The obfuscation implementation method according to the present embodiment includes a step of separating at least a portion of the code and storing it in an external server (S110), a step of hiding a string corresponding to the separated code (S120), and a step of protecting a screen element (S130).

[0098] In the step (S110) of separating at least a portion of the code and storing it on an external server, the code separation unit (131) can separate at least a portion of the code included in the application and store it on an external server.

[0099] In the step (S110) of separating at least a portion of the code and storing it on an external server, the code separation unit (131) can perform static contamination analysis on the application to identify data that may be susceptible to data leakage.

[0100] At this time, data that has the potential for data leakage may have a flow that starts from the source, which is the entry point of static contamination analysis, to the sink, where the data flows out.

[0101] And in the step (S110) of separating at least a part of the code and storing it on an external server, the code separation unit (131) can separate the code files corresponding to the identified data into a predetermined number.

[0102] Here, the code file is a file with the extension dex, and in the step (S110) of separating at least a part of the code and storing it on an external server, the code separation unit (131) can separate the code dex file into an SC (sensitive) dex file, a UDC (User Define Class) dex file, and a Classes dex file.

[0103] Meanwhile, the step (S120) of hiding a string corresponding to a separated code may be a step in which the hiding unit (135) hides a string corresponding to the separated code in a pre-prepared data storage space.

[0104] In the step of hiding a string (S120), the hiding unit (135) can extract a string from a file of separated code and determine the location where the extracted string is to be inserted within the data storage space.

[0105] And in the step of hiding the string (S120), the hiding unit (135) inserts the extracted string into a data storage space, repackages it, and then signs it using a signature, thereby creating an Android application package (APK) file in which the string is hidden.

[0106] Meanwhile, the step (S130) of protecting the screen element may be a step in which the screen protector (133) protects the screen element of the Android terminal.

[0107] In the step (S130) of protecting these screen elements, the screen protector (133) can change the screen elements, which are information output through the screen, by using at least one of a plurality of obfuscation techniques prepared in advance.

[0108] The obfuscation implementation method of the present invention may be implemented in the form of program commands that can be executed by various computer components and recorded on a computer-readable recording medium. The computer-readable recording medium may include program commands, data files, data structures, etc., either singly or in combination.

[0109] The program commands recorded on the above computer-readable recording medium may be specially designed and configured for the present invention or may be known and available to those skilled in the art of computer software.

[0110] Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, and flash memory.

[0111] Examples of program instructions include not only machine language codes, such as those generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter or the like. The hardware device may be configured to operate as one or more software modules to perform processing according to the present invention, and vice versa.

[0112] Although various embodiments of the present invention have been illustrated and described above, the present invention is not limited to the specific embodiments described above, and various modifications can be made by a person having ordinary skill in the art to which the present invention pertains without departing from the gist of the present invention as claimed in the claims, and such modifications should not be understood individually from the technical idea or prospect of the present invention.

[0113] Meanwhile, FIG. 16 is a graph showing the results of an experiment to explain the effectiveness of an obfuscation implementation method according to one embodiment of the present invention.

[0114] Specifically, FIG. 16 is a graph showing the percentage exposed through dynamic analysis and static analysis for an original application (original), an application obfuscated by performing only code separation (Sensitive Code Split), an application obfuscated by performing only screen element protection (Screen Element Protection (SEP)), an application obfuscated by performing only data hiding (Android Data Storage Space Utilization (ADSSU)), and an application obfuscated through an obfuscation implementation method according to the present embodiment (new obfuscation).

[0115] As can be seen from Figure 16, it has been proven that the obfuscation implementation method of the present invention, which includes all three techniques of code separation, screen element protection, and data hiding, can more effectively protect important information of an application.

[0116] [Explanation of symbols]

[0117] 100: Obfuscation implementation device 110: Communication unit

[0118] 120: Storage unit 130: Control unit

[0119] 131: Code separation section 133: Screen protection section

[0120] 135: Hidden Secret

Claims

1. A method for implementing obfuscation in an obfuscation implementation device to prevent reverse obfuscation attacks on applications of Android terminals, A step of separating at least a portion of the code included in the above application and storing it on an external server, and hiding a string corresponding to the separated code in a pre-arranged data storage space; and A method for implementing obfuscation, comprising a step of protecting a screen element of the Android terminal.

2. In paragraph 1, Separating the above code is, Perform static contamination analysis on the above application to identify data that may be susceptible to data leakage; The data that may be subject to the above data leak is: An obfuscation implementation method in which a flow exists starting from the source, which is the entry point of the above static contamination analysis, to the sink, where data flows out.

3. In paragraph 2, The file of the above code is a file with the extension dex, Separating the above code is, An obfuscation implementation method that separates the dex file of the code corresponding to the above-mentioned identified data into an SC (sensitive) dex file, a UDC (User Define Class) dex file, and a Classes dex file.

4. In paragraph 2, In the above hiding step, Extract the above string within the file of the above separated code, Determine the location where the extracted string is to be inserted within the above data storage space, An obfuscation implementation method that creates an Android application package (APK) file in which a string is hidden by inserting the extracted string into the data storage space, repackaging it, and then signing it using a signature.

5. In paragraph 1, In the step of protecting the above screen elements, An obfuscation implementation method that changes a screen element, which is information output through a screen, by using at least one of a plurality of pre-prepared obfuscation techniques.

6. A computer-readable recording medium having recorded thereon a computer program for performing the obfuscation implementation method according to paragraph 1.

7. As an obfuscation implementation device to prevent reverse obfuscation attacks on applications of Android terminals, A code separation unit that separates at least a portion of the code included in the above application and stores it on an external server; A hiding unit that hides a string corresponding to the above separated code in a pre-arranged data storage space; and An obfuscation implementation device including a screen protector that protects the screen elements of the above Android terminal.

8. In paragraph 7, The above code separator separates the above code, Perform static contamination analysis on the above application to identify data that may be susceptible to data leakage; The data that may be subject to the above data leak is: An obfuscation implementation device in which a flow exists starting from the source, which is the entry point of the above static contamination analysis, to the sink, where data flows out.

9. In paragraph 8, The file of the above code is a file with the extension dex, The above code separation unit is, An obfuscation implementation device that separates the dex file of the code corresponding to the above-identified data into an SC (sensitive) dex file, a UDC (User Define Class) dex file, and a Classes dex file.

10. In paragraph 8, The above hidden part is, Extract the above string within the file of the above separated code, Determine the location where the extracted string is to be inserted within the above data storage space, An obfuscation implementation device that creates an Android application package (APK) file in which a string is hidden by inserting the extracted string into the data storage space, repackaging it, and then signing it using a signature.

11. In paragraph 7, The above screen protector, An obfuscation implementation device that changes a screen element, which is information output through a screen, using at least one of a plurality of pre-arranged obfuscation techniques.

Citation Information

Patent Citations

  • Apparatus for obfuscation of application code and method for same​

    KR101328012B1

  • File server, file transfer method thereof and file tamperproof system

    KR101436536B1

  • Code obfuscation method and electronic device supporting the same

    KR1020160114903A

  • Deobfuscation apparatus and method for data flow analysis of obfuscated applications

    KR102514888B1

  • Operating system-level management of multiple item copy and paste

    US20220206995A1

Cited By

  • Web application anti-debugging method based on dynamic code distribution and full-link verification

    CN120705841A