KR102323276B1 - Method and apparatus for converting application - Google Patents

Abstract

Disclosed are a method and device for converting an application. The method for converting the application according to one embodiment comprises: a step of each decompiling a target application and a calling application that calls a security function to be added to the target application to generate a first bytecode for the target application and a second bytecode for the calling application; a step of extracting a calling code for calling the security function from the second bytecode; a step of adding the extracted calling code to the first bytecode; a step of performing code optimization to prevent a collision between the calling code and the remaining code in the first bytecode to which the calling code is added; and a step of recompiling the first bytecode on which the code optimization is performed. Therefore, the present invention is capable of allowing various security functions to be applied without conflict with an existing code.

Description

APPLICATION CONVERSION METHOD AND APPARATUS

Embodiments of the present invention relate to app wrapping techniques.

With the popularization of smart devices, many companies are introducing BYOD (Bring Your Own Device) policies that utilize personal smart devices for work. Although BYOD has advantages such as improved work efficiency and cost reduction, security threats such as confidential data leakage are being raised as work data is stored on personal smart devices.

To address these security threats, solutions such as Enterprise Mobility Management (EMM) have been introduced to provide customized security services for smart device security and corporate policies. In order to provide security services according to corporate policy, it is necessary to analyze the original source code of the application and add the security function to the location where the security function is required. This task has to be done every time the corporate policy changes, so it takes a very long time to customize the application according to the policy.

On the other hand, there is an app wrapping method to apply a security function without the original source code of the application. App wrapping is a technology that adds security function code directly to the application file without the original source code of the application at the bytecode level. However, it is known that it is difficult to make the application run smoothly after adding the security function code at the bytecode level.

In particular, the bytecode of Android, smali code, is a register-based memory that can be used for each method area is limited, so after adding the security function code An overflow error occurs in the , and the application does not run normally.

Republic of Korea Patent Publication No. 10-2018-0053872 (published on May 24, 2018)

SUMMARY Embodiments of the present invention are to provide an application conversion method and apparatus for adding a security function to an application.

In an application conversion method according to an embodiment, a first bytecode for the target application and the calling application by decompile of a target application and a calling application that calls a security function to be added to the target application, respectively generating a second bytecode for extracting a calling code for calling the security function from the second bytecode; adding the extracted calling code to the first bytecode; performing code optimization to prevent a collision between the calling code and the remaining codes in the first bytecode to which the calling code is added; and recompiling the first bytecode on which the code optimization is performed.

The calling code may be a code for calling the security function in a security application providing the security function.

The performing of the code optimization may include performing the code optimization by modifying one or more parameters included in the remaining code.

The performing of the code optimization may include: identifying a parameter whose variable name overlaps with a parameter included in the calling code in the remaining code; and performing the code optimization by modifying the code associated with the identified parameter.

An apparatus according to an embodiment includes one or more processors; and a memory storing one or more programs to be executed by the one or more processors, the one or more programs to decompile a target application and a calling application that calls a security function to be added to the target application, respectively. ) to generate a first bytecode for the target application and a second bytecode for the calling application; extracting a calling code for calling the security function from the second bytecode; adding the extracted calling code to the first bytecode; performing code optimization to prevent a collision between the calling code and the remaining codes in the first bytecode to which the calling code is added; and instructions for executing the step of recompiling the first bytecode on which the code optimization has been performed.

The calling code may be a code for calling the security function in a security application providing the security function.

The performing of the code optimization may include performing the code optimization by modifying one or more parameters included in the remaining code.

The performing of the code optimization may include: identifying a parameter whose variable name overlaps with a parameter included in the calling code in the remaining code; and performing the code optimization by modifying the code associated with the identified parameter.

According to embodiments of the present invention, various security functions can be applied to an application at the bytecode level without conflicting with the existing code without the original source code of the application.

1 is a block diagram illustrating and describing a computing environment including a computing device suitable for use in example embodiments;
2 is a flowchart of an application conversion method according to an embodiment;
FIG. 3 is a diagram for exemplarily explaining a collision between a calling code added to the first bytecode and the remaining codes of the first bytecode; FIG.
4 is a diagram for exemplarily explaining code optimization according to an embodiment;

Hereinafter, specific embodiments of the present invention will be described with reference to the drawings. The following detailed description is provided to provide a comprehensive understanding of the methods, apparatus, and/or systems described herein. However, this is merely an example and the present invention is not limited thereto.

In describing the embodiments of the present invention, if it is determined that the detailed description of the known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description thereof will be omitted. In addition, the terms to be described later are terms defined in consideration of functions in the present invention, which may vary according to intentions or customs of users and operators. Therefore, the definition should be made based on the content throughout this specification. The terminology used in the detailed description is for the purpose of describing embodiments of the present invention only, and should in no way be limiting. Unless explicitly used otherwise, expressions in the singular include the meaning of the plural. In this description, expressions such as “comprising” or “comprising” are intended to indicate certain features, numbers, steps, acts, elements, some or a combination thereof, and one or more other than those described. It should not be construed to exclude the presence or possibility of other features, numbers, steps, acts, elements, or any part or combination thereof.

1 is a block diagram illustrating and describing a computing environment including a computing device suitable for use in example embodiments.

In the embodiment shown in FIG. 1 , each component may have different functions and capabilities other than those described below, and may include additional components in addition to those described below.

Computing environment 10 includes computing device 12 . In one embodiment, the computing device 12 may be a device for performing an application conversion method to be described later.

Computing device 12 includes at least one processor 14 , computer readable storage medium 16 , and communication bus 18 . The processor 14 may cause the computing device 12 to operate in accordance with the exemplary embodiments discussed above. For example, the processor 14 may execute one or more programs stored in the computer-readable storage medium 16 . The one or more programs may include one or more computer-executable instructions that, when executed by the processor 14, configure the computing device 12 to perform operations in accordance with the exemplary embodiment. can be

Computer-readable storage medium 16 is configured to store computer-executable instructions or program code, program data, and/or other suitable form of information. The program 20 stored in the computer readable storage medium 16 includes a set of instructions executable by the processor 14 . In one embodiment, computer-readable storage medium 16 includes memory (volatile memory, such as random access memory, non-volatile memory, or a suitable combination thereof), one or more magnetic disk storage devices, optical disk storage devices, flash It may be memory devices, other forms of storage medium accessed by computing device 12 and capable of storing desired information, or a suitable combination thereof.

Communication bus 18 interconnects various other components of computing device 12 , including processor 14 and computer readable storage medium 16 .

Computing device 12 may also include one or more input/output interfaces 22 and one or more network communication interfaces 26 that provide interfaces for one or more input/output devices 24 . The input/output interface 22 and the network communication interface 26 are coupled to the communication bus 18 . Input/output device 24 may be coupled to other components of computing device 12 via input/output interface 22 . Exemplary input/output device 24 may include a pointing device (such as a mouse or trackpad), a keyboard, a touch input device (such as a touchpad or touchscreen), a voice or sound input device, various types of sensor devices, and/or imaging devices. input devices, and/or output devices such as display devices, printers, speakers and/or network cards. The exemplary input/output device 24 may be included in the computing device 12 as a component constituting the computing device 12 , and may be connected to the computing device 12 as a separate device distinct from the computing device 12 . may be

2 is a flowchart of an application conversion method according to an embodiment.

The application conversion method shown in FIG. 2 is for converting a target application to be converted into an application to which a security function is added, and may be performed, for example, by the computing device 12 shown in FIG. 1 .

Referring to FIG. 2 , first, the computing device 12 decompiles a target application and a calling application, respectively, and a bytecode for the target application (hereinafter, a first bytecode) and a byte for the calling application. A code (hereinafter, referred to as a second byte code) is generated ( 210 ).

In this case, the target application may refer to an application to which one or more security functions provided by a security application, such as Enterprise Mobility Management (EMM), Mobile Device Management (MDM), etc. are applied.

Also, the calling application may refer to an application including a calling code for calling a security function provided by the security application.

Meanwhile, according to an embodiment, the target application and the calling application may be, for example, files in the format of an Android Application Package (APK) executed in the Android operating system disclosed by Google, and the first byte The code and the second bytecode may be, for example, Smali code, but are not limited thereto.

In addition, according to an embodiment, the security function provided by the security application may be in the form of, for example, an application programming interface (API), but according to an embodiment, it may be in the form of an Android activity.

Thereafter, the computing device 12 extracts a calling code for calling a security function to be added to the target application from the second bytecode, and then adds the extracted calling code to the first bytecode ( 220 ).

Thereafter, the computing device 12 performs code optimization to prevent a collision between the calling code added to the first bytecode and the remaining codes of the first bytecode ( 230 ).

In this case, according to an embodiment, the computing device 12 may perform code optimization by modifying one or more parameters included in the remaining codes of the first bytecode.

Specifically, the computing device 12 identifies a parameter whose variable name overlaps in the calling code added to the first bytecode and the remaining code of the first bytecode, and performs code optimization by correcting the code related to the parameter in the remaining code can do.

3 is a diagram for exemplarily explaining a collision between a calling code added to the first bytecode and the remaining codes of the first bytecode.

Referring to FIG. 3 , the parameter “p0” used in some codes 320 among the calling codes 310 added to the first bytecode 300 is a partial code 330 of the remaining codes of the first bytecode 330 . ) has the same variable name as the included parameter "p0" used in ), so an error occurs when running the application. Therefore, when the calling code 310 is added to the first bytecode 300 , it is necessary to perform code optimization so as not to conflict with parameters used in the remaining codes.

4 is a diagram for exemplarily explaining code optimization according to an embodiment.

Referring to FIG. 4 , the computing device 12 globalizes “activity”, which is a parameter whose variable name overlaps with a parameter included in the calling code added to the first bytecode, from the remaining codes of the first bytecode for code optimization. It can be declared as a variable (410). In this case, the global variable name may be determined not to overlap with other variable names.

Thereafter, the computing device 12 designates a parameter having a corresponding variable name as “this” in the rest of the code (420), and changes the code so that the global variable name declared in 410 is used in the method in which the corresponding parameter is called (430) This allows code optimization to be performed.

Referring back to FIG. 2 , when the code optimization is completed, the computing device 12 recompiles the first bytecode on which the code optimization is performed to generate a target application to which a security function is added ( 240 ).

In this case, according to an embodiment, signature information generated through an electronic signature may be added to the generated target application.

On the other hand, in the flowchart shown in FIG. 2, at least some of the steps are performed in a reversed order, performed together with other steps, omitted, divided into detailed steps, or one or more steps not shown are added. can be performed.

Although the present invention has been described in detail through representative embodiments above, those of ordinary skill in the art to which the present invention pertains can make various modifications to the above-described embodiments without departing from the scope of the present invention. will understand Therefore, the scope of the present invention should not be limited to the described embodiments and should be defined by the claims described below as well as the claims and equivalents.

10: Computing Environment
12: computing device
14: Processor
16: computer readable storage medium
18: communication bus
20: Program
22: input/output interface
24: input/output device
26: network communication interface

Claims (8)

generating a first bytecode for the target application and a second bytecode for the calling application by decompiling a target application and a calling application that calls a security function to be added to the target application, respectively ;
extracting a calling code for calling the security function from the second bytecode;
adding the extracted calling code to the first bytecode;
performing code optimization to prevent a collision between the calling code and the remaining codes in the first bytecode to which the calling code is added; and
and recompiling the first bytecode on which the code optimization is performed.
The method according to claim 1,
The calling code is a code for calling the security function in a security application providing the security function, the application conversion method.
The method according to claim 1,
In the performing the code optimization, the code optimization is performed by modifying one or more parameters included in the remaining code.
The method according to claim 1,
The performing of the code optimization may include: identifying a parameter whose variable name overlaps with a parameter included in the calling code in the remaining code; and
performing the code optimization by modifying a code associated with the identified parameter.
one or more processors; and
A device comprising a memory storing one or more programs executed by the one or more processors,
the one or more programs,
generating a first bytecode for the target application and a second bytecode for the calling application by decompiling a target application and a calling application that calls a security function to be added to the target application, respectively ;
extracting a calling code for calling the security function from the second bytecode;
adding the extracted calling code to the first bytecode;
performing code optimization to prevent a collision between the calling code and the remaining codes in the first bytecode to which the calling code is added; and
and instructions for executing the step of recompiling the first bytecode on which the code optimization has been performed.
6. The method of claim 5,
The calling code is a code for calling the security function in a security application that provides the security function.
6. The method of claim 5,
The performing of the code optimization may include performing the code optimization by modifying one or more parameters included in the remaining code.
6. The method of claim 5,
The performing of the code optimization may include: identifying a parameter whose variable name overlaps with a parameter included in the calling code in the remaining code; and
performing the code optimization by modifying code associated with the identified parameter.

Images