KR101941274B1 - Method and apparatus for actuating an application without cessation - Google Patents

Abstract

The present invention relates to a system and method for changing an application for security while driving the same without interruption. The method for driving an application without interruption comprises: a step in which an agent terminal drives a first application, which is a first version for a specific application, in a first target terminal; a step in which the agent terminal receives a variation code related to the specific application from an application variation server; a step in which the agent terminal generates a second application, which is a second version for the specific application, in a second target terminal wherein the second application replaces a part code of the specific application with the variation code; and a step in which the agent terminal stops the first application in the first target terminal, and drives the second application in the second target terminal.

Description

[0001] METHOD AND APPARATUS FOR ACTUATING AN APPLICATION WITHOUT CESSATION [0002]

The present invention relates to techniques for protecting applications from hacking attempts. More particularly, the present invention relates to a technique for continuously running an application while continuously changing some code of an application to protect the application from hacking.

Advanced devices such as smart phones have played an important role in life, and users have stored various personal information in advanced devices. Also, in case of a server that controls a plurality of devices, various public information is stored in the server. These advanced devices are often connected to the network to exchange information. Therefore, when the smartphone is lost, hacked, or the server is hacked, the risk of exposure of fatal personal information or public information to the outside is increasing.

Along with the development of security technologies, hacking techniques to steal information are also evolving.

Reverse engineering is one of the most used methods in hacking technology.

Reverse engineering can be understood as the reverse of the process of developing an application. Generally, the process of developing an application is through compilation and packaging from the source code to generate the installation files. On the contrary, reverse engineering is the process of checking the source code through installation files, packaging, compiling, and source code.

Reverse engineering is a technique that is primarily aimed at finding defects in the development process or repairing defects in the product if the source code is undisclosed. However, in recent years, it has been used extensively for the purpose of grasping the structure of internal systems as a means of hacking for the purpose of stealing key technologies of competitive products or borrowing ideas.

Reverse engineering is easily exploited by hackers, along with repackaging techniques. You can reverse-engineer your application to the source code level and then recompile and package critical code. When creating and distributing similar applications through this, it is possible for the original application to steal personal information and public information from a good user and cause unintended behavior of the original application.

As a protection against hacking attempts such as reverse engineering, a method of continuously changing the entire code of the application or a part of the code has been proposed. If an application code is changed periodically or aperiodically, even if the previous application code is exposed by a previous hacking attempt, the application function can be safeguarded because the application runs in a different code than the exposed code.

However, such a change may cause a side effect of shutting down the application because the server or device needs to stop the application service and restart the application when the application is changed.

The present invention can provide a redundant server structure for continuous application execution while continuously changing applications for application security.

In addition, the present invention can provide a single server structure utilizing virtual space for application execution without interruption while changing applications.

A method of running an uninterrupted application of the present invention includes: causing an agent terminal to run a first application at a first target terminal, the first application being a first version for a particular application; The agent terminal receiving a variation code associated with the specific application from an application variation server; Wherein the agent terminal generates a second application, a second version for the specific application, at a second target terminal, wherein the second application replaces some code of the specific application with the mutation code, step; And suspending the first application at the first target terminal and the second application at the second target terminal.

Wherein the method further comprises controlling the agent terminal to test whether the second application is normally operating in the second target terminal, and when the agent terminal is in the normal operation, executing the second application . Meanwhile, in the testing step, if the normal operation is not performed, the agent terminal transmits error information to the application server. And the agent terminal includes adding transition failure information to the history information.

Wherein the agent terminal changes the first target terminal from the active mode to the standby mode and the second target terminal changes from the standby mode to the active mode in the step of driving the second application, And the change is made simultaneously.

A method of running an uninterrupted application is such that the first application and the second application are different versions of the particular application and the functional operation is the same.

A method for operating an application without interruption includes the steps of: after the step of driving the second application, the agent terminal replaces the first code of the first application with the mutation code to generate the second application; Controlling the agent terminal to test whether the second application is operating normally in the first target terminal; And causing the agent terminal to stop the second application at the second target terminal and to start the second application at the first target terminal only when normal operation is performed. Wherein the agent terminal further comprises the step of adding the mutation code and information associated with the generated second application to the history information, wherein the history information includes source information for the particular application and the first application related information Is stored. In addition, a method of operating an application without interruption includes the steps of the agent terminal confirming the second application execution error; And causing the agent terminal to use the history information to restart the first application at the first target terminal.

A method of running an application without interruption includes: after the step of running the second application, the agent terminal receiving a second mutation code different from the mutation code from the application server; Wherein the agent terminal generates a third application, which is a third version for the specific application, at the first target terminal, wherein the third application replaces the partial code of the specific application with the second mutation code , The generating step; The agent terminal suspends the second application at the second target terminal and activates the third application at the first target terminal. Here, the non-interruptible application driving method further includes a step of the agent terminal testing whether the third application is normally running in the first target terminal, and only when the third application is running normally, Proceed to step.

According to another embodiment of the present invention, there is provided a terminal equipped with an agent program, wherein the agent program executes a first application, which is a first version for a specific application, from a first target terminal, A second target terminal for generating a second application for the specific application in the second target terminal and controlling the second target terminal to test whether the second application is normally operated, The second application is programmed to stop the first application at the first target terminal and to run the second application at the second target terminal only if the first application is part of the specific application, The above code Code.

Wherein the terminal is characterized in that the first application and the second application are different versions of the specific application and the functional operation is the same.

The terminal also stores history information, and the agent program adds the mutation code and information related to the second application to the history information, and the history information includes source information for the specific application, And this period is stored.

According to another embodiment of the present invention, an application-driven terminal comprises: a storage unit for storing a first application, which is a first version for a specific application; And an agent unit for controlling operations of the application including the first application and driving the first application in the storage unit, wherein when the mutation code relating to the specific application is received from the application mutation server, Generating a second application, which is a second version for the specific application, in the virtual space in the application-activated terminal, stopping the first application in the storage unit, and controlling the second application in the virtual space, The second application replaces some code of the specific application with the mutation code.

Further, the agent unit tests whether the second application is normally operated in the virtual space, and performs control to drive the second application only when the second application is normally running.

In addition, the virtual space is a virtual container.

Wherein the agent unit generates the second application by replacing some code of the first application with the mutation code in the storage unit after driving the second application in the virtual space, The second application is stopped in the virtual space only when the application is normally running, and the storage unit controls to drive the second application. Here, the application driving terminal controls to delete the virtual space after driving the second application in the storage unit.

According to another embodiment of the present invention, a method for running an application without interruption includes the steps of causing an application-driven terminal to execute a first application, which is a first version for a specific application, in a storage unit; Receiving a variation code associated with the specific application from an application variation server; Generating a second application, which is a second version for the specific application, in the virtual space, wherein the second application replaces a part of the code of the specific application with the mutation code; Testing whether the second application is operating normally in the virtual space; And stopping the first application in the storage unit and driving the second application in the virtual space only when normal driving is performed.

Here, the first application and the second application are different versions of the specific application, the functional operation is the same, and the virtual space is a virtual container.

According to at least one embodiment of the present invention, it is possible to provide an effect of continuously changing an application running in a server system structure to maintain security.

Further, the present invention can provide an effect of guaranteeing continuous application execution because the application is continuously changed while the execution is not interrupted in the change process.

1 is a diagram showing a system configuration diagram between an application server and a target server according to a redundancy structure;
Figure 2 illustrates one embodiment of an application application operation in accordance with a redundancy structure;
Figure 3 illustrates two embodiments of an application application operation in accordance with a redundancy structure;
Figure 4 illustrates three embodiments of an application application operation in accordance with a redundancy structure;
5 illustrates a system configuration diagram of an application server and a target server according to a single structure;
6 is a view for explaining a virtual container structure related to a single structure;
Figure 7 illustrates one embodiment of an application application operation in accordance with a single structure;
Figure 8 (a) illustrates two embodiments of an application application operation in accordance with a single structure;
Figure 8 (b) illustrates three embodiments of an application application operation in accordance with a single architecture;
9 is a diagram showing an example of application of a variation code to an application;

Hereinafter, a mobile terminal related to the present invention will be described in detail with reference to the drawings. The suffix "module" and " part "for the components used in the following description are given or mixed in consideration of ease of specification, and do not have their own meaning or role.

The terminal or terminal described herein may include a server, a mobile phone, a smart phone, a laptop computer, a digital broadcasting terminal, a PDA (personal digital assistant), a portable multimedia player (PMP) have. However, it will be readily apparent to those skilled in the art that the configuration according to the embodiments described herein may be applied to a fixed terminal such as a digital TV, a desktop computer, or the like, except when applicable only to a mobile terminal. In the present specification, the term 'server' is used for the sake of convenience of description, but it may be expressed as a terminal or a terminal having the same function.

1 is a system configuration diagram between an application server and a target server according to the redundancy structure of the present invention.

The present invention can utilize a server redundancy structure for uninterrupted execution of an application. The redundant structure referred to in the present invention means a structure using two servers for application execution and uninterrupted operation.

Referring to FIG. 1, the first server 110 and the second target server 120 have two server structures. A client terminal 160, a first target server 110, a second target server 120, an application server 140, an agent unit 130 and a duplication device 135 are shown.

The first target server 110 and the second target server 120 are devices that store applications and execute applications. The target server 110 or 120 may be a fixed or mobile terminal. The first target server 110 may include a communication unit 112, a control unit 114, and a storage unit 116. Although not shown in the figure, it may include a user input portion and an output portion as necessary. The second target server 120 may also include a communication unit 122, a control unit 124, and a storage unit 126.

The first target server 110 and the second target server 120 may be identical in terms of performance such as processing speed and storage capacity, but may be set so that one server has better performance. For example, the first target server 110 having higher performance may be set as a main server, and the second target server 120 may be set as an auxiliary server. Accordingly, the main execution of the application is executed by the first target server 110 which is the main server, but only when the issue of the application change occurs, the second target server 120 which is an auxiliary server may be used.

In the figure, the agent unit 130 is shown as being included in the first target server 110. However, according to another design, the agent unit 130 may be configured as an independent device separate from the first target server 110 and the second target server 120. [ Functionally, the agent unit 130 can control the mutual operation for the applications running on the two servers so that it can operate independently of the first target server 110 and the second target server 120 have.

Although the duplication device 135 is also shown as being included in the first target server 110, the duplication device 135 is also a device separate from the first target server 110 and the second target server 120 .

The application variation server 140 is a server that manages an application installed in the target server 110. Specifically, it is a server that manages to replace some code of an application with a mutation code continuously. The application variation server 140 may include a communication unit 142, a control unit 144, and a storage unit 146. [

The communication unit 112 communicates with the first target server 110 and the external network or between the target terminal 110 and the client terminal 160 through the duplication unit 135, Lt; RTI ID = 0.0 > and / or < / RTI > The communication unit 112 may transmit and receive various information such as a mutual code from the agent unit 130. [ Although not shown in the figure, the communication unit 112 may directly communicate with the communication unit 122 of the second target server 120, as the case may be.

 The communication units 112 and 122 of the target server may download the application from the application storage server or the like via the network. Optionally, an application may be received from the agent portion 130. The communication units 112 and 122 may receive various information such as a mutation code provided by the application server 130 to the agent unit 130. [

The communication unit 112 of the first target server can transmit and receive various signals such as a service request from the client terminal 160 through the duplexer 135. When the first target server 110 is in the active mode and the application is running, the duplication device 135 may transmit the service request to the communication unit 112 of the first target server. The response to the service request may be transmitted directly to the client terminal 160 by the communication unit 112 of the first target server without going through the duplication unit 135. [

The duplexer 135 receives a service request signal from the client terminal 160. The client terminal 160 accesses the entirety of the first target server 110 and the second target server 120, that is, the redundant server, through a public IP. That is, when the client terminal 160 connects to the redundant server or the server system through the public IP through the external network, the client terminal 160 is connected to the redundant device 135. After connecting to the redundant server through public IP, the internal network (the first target server and the second target server) are connected to each other using the internal network address.

When the duplication device 135 is connected to the client terminal 160 and receives the service request, the duplication device 135 delivers the request to the first target server or the second target server according to the network requestor (TCP IP protocol configuration details). When the duplication device 135 receives the service request, it transfers the service request to the first target server and the second target server in the active mode, that is, the server in which the application is running. On the other hand, as an example of the duplexer, there is a load balancer, L4 switch.

The controllers 114 and 124 control the overall operation of the target servers 110 and 120. For example, the control unit may control various functions of the communication units 112 and 122 and the storage units 116 and 126 in addition to the functions of the control unit itself. The control units 114 and 124 can execute applications installed in the target servers 110 and 120. [

The control units 114 and 124 can change the application by applying the received mutation code according to an instruction from the agent unit 130. [ It is also possible to stop the application from running for a change.

The control units 114 and 124 may further include an agent program different from the agent unit 140. Application mutation code replacement functions can be performed through the agent program. The agent program may perform functions related to code substitution of multiple applications. A change of the application code or a module is dynamically performed and the application is re-loaded to cause the replacement of the execution process. Depending on the application, there may occur a case where the application is restarted after the execution is stopped, There may be cases where only the configuration module can be restarted. At this time, the agent program is preferably operated as a background service. This is because it is not visible to the user, and it is ideal from the service point of view to naturally cause the transformation to run in the application.

The agent unit 140 receives the mutation code from the application mutation server 140 and may transmit the mutation code to the first target server 110 or the second target server 120. [ The agent unit 140 continuously checks the target server on which the application is currently running. For example, the first target server is in the active mode and the second target server continuously checks the status information that it is the standby mode. Based on the confirmed state, the mutation code may be provided to the target servers, and in some cases, the application start instruction, the stop indication, and the like may be issued.

The storage units 116 and 126 may store programs for processing and controlling the control units 114 and 124 and store the input / output data (for example, mutation codes for application code mutation) For example.

The first target server 110 and the second target server 120 are functionally similar. Alternatively, the first target server 110 may additionally include the agent unit 130 as a main server.

On the other hand, the application server 140 has a structure similar to that of the target server. That is, the application server 140 has a communication unit 142, a control unit 144, and a storage unit 146. However, the functions of the target server and the variation server 140 are partially different.

The communication unit 142 of the application server 140 transmits / receives various information to / from the target server or the agent unit 130. For example, the communication unit 142 may transmit an application mutation code, an application authentication code, and the like to the agent unit 130 and receive a mutable confirmation signal therefrom.

The control unit 144 controls the overall operation of the application transition server 140. Various operations such as generation of a mutation code of the application server 140 can be controlled by the control unit 144. [ For example, the control unit 144 may generate a mutation code for the application when a predetermined period has been reached, or when a specific event occurrence has been confirmed.

Although not shown in the figure, the control unit 144 may separately include a code management unit. The code management unit may perform functions related to such mutation codes. The code management unit can manage a plurality of applications to be protected, and it is preferable to manage the applications to be registered, modified, and deleted in the storage unit 146. [ On the other hand, a security function for managing registration, modification, and deletion of a user account that can access the management target application can be implemented as needed.

In terms of system management, functions such as management process setting, security policy setting, code randomization (obfuscation) and schedule management should be implemented.

When the software becomes a self-mutation point according to the schedule, it commands the agent to transfer the module file from the repository of the code management unit, and processes the application variation through the file processing process.

At this time, it is desirable to implement a process of performing integrity check (integrity check) in the file processing process to check whether the network transmission is up / modulated.

Management of the application can be performed through the code management unit. That is, the main code of the protection target application can be specified through the code management unit, and the area to which the obfuscation technique is applied can be set and managed.

The storage unit 146 stores information about the application under the control of the control unit 144. [ For example, the storage unit 146 stores application source codes, and can store information on various mutation codes, mutation code history information, codes of existing applications to which mutation codes are applied, and the like.

The various embodiments described herein may be embodied in a recording medium readable by a computer or similar device using, for example, software, hardware, or a combination thereof.

In accordance with a hardware implementation, the embodiments described herein may be implemented as application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays May be implemented using at least one of a processor, controllers, micro-controllers, microprocessors, and other electronic units for performing other functions. In some cases, The embodiments to be described can be implemented by the control unit itself.

According to a software implementation, embodiments such as the procedures and functions described herein may be implemented in separate software modules. Each of the software modules may perform one or more of the functions and operations described herein. Software code can be implemented in a software application written in a suitable programming language. The software code is stored in a memory and can be executed by the control unit.

2 is a diagram showing one embodiment of an application changing operation according to a redundancy structure.

In this embodiment, it can be largely divided into a normal process (A), a conversion process (B), and a normal process (C).

The normal process (A) is a state in which the application A (App A) is running in the first target server 110 before the mutation code is applied, that is, the application immediately before the change is the main server. The first target server 110, which is a main server, stores the application App A and normally runs the application (S202). If the duplication device 135 receives a service request (1) for the application from the client terminal 160 (S204), the duplication device 135 determines that the application App A is being driven by the first target server 110 And transmits the service request to the first target server 110 (S205). When the first target server 110 receives the service request, the first target server 110 transmits a response to the service through the application App A (S206).

After the normal process (A), the conversion process (B) is applied. The conversion process (B) shows a process in which the application code is replaced with the mutation code to change the application. Here, the application App A 'represents an application in which some codes of the application App A have been changed to mutation codes. App A 'and App A are functionally identical.

The application variation server 140 generates a variation code for App A (S212). The application variation server continuously generates mutation codes for some of the codes of the application periodically or aperiodically. This is for changing the application using the mutation code for security of the application. These mutation codes are transmitted to the target servers installed with the application through the agent unit, and replace some codes of the applications with mutation codes.

The application server 140 provides the server 130 with a code for the variation S214 and the agent 130 provides the code to the second target server 120 that is currently in standby, (S216). And the second target server 120 stores the application App A. However, unlike the first target server 110, App A is not driven and is in a standby mode. When receiving an instruction from the agent unit 130, the second target server 120 applies the mutation code to change App A to App A '(S220). After the change, the App A 'is driven to test whether or not the device operates normally (S222). Here, the App A 'drive is an internal drive for testing, not an entire system. If the normal operation is confirmed, the second target server 120 transmits a normal operation verification signal to the agent unit 130 (S224)

Whether the normal operation is performed or not is confirmed by verifying the set value and verifying whether or not the normal operation is performed by attempting to access the application A '(mutated state) of the second target server 120 directly from the internal network. For example, a service request is made to a second target server in a standby state in a form of querying by accessing a service web page URL, and it is checked whether a proper response (for example, an HTTP 404 error does not occur) It is possible to confirm whether or not the application App A 'of the second target server in the normal state operates. If a generic program module is created in advance and all of the test routines succeed, it can be regarded as a normal operation. Hereinafter, the normal operation verification test in another embodiment is performed in the same manner.

The agent unit 130 waits for a signal and confirms a success or failure signal. When receiving the normal operation signal, the agent unit 130 transmits an App drive stop instruction to the first target server (S228) and transmits an App drive instruction to the second target server (S226). As a result, the application A that was driven by the first target server 110 is stopped (S230), and the application A 'changed from the application A by the second target server 120 is successfully activated (S229). Along with this, the agent unit 130 may change the first target server 110 from active to standby mode and change the second target server 120 from standby to active mode.

When the service request 2 is received from the client terminal 160 at the duplication device 135 at step S232, the duplication device 135 transfers the request to the second target server 120, The server 120 responds to the client terminal through the application A 'in response to the request (S236).

Following the conversion process (B), the normal process (C) is performed. That is, the process is performed so that the application of the first target server 110, which is the main server, can be driven again. The agent unit 130 provides the mutation code to the first target server 110 and instructs the mutual code application (S240). In S240, when the first target server 110 receives an instruction, the first target server 110 applies a mutation code to App A, changes the state to App A '(S242), drives the App A' (S244). The agent unit 130 transmits a normal operation verification acknowledgment signal to the agent unit 130 in step S245 and transmits an App stop command to the second target server 120 S246), and transmits an App drive instruction to the first target server 110 (S248). Accordingly, the second target server 120 stops driving the App A '(S249), and the first target server 110 drives the App A' (S250). At the same time, the first target server 110 becomes active again, and the second target server 120 becomes a standby mode.

Through the above process, the application of the first target server 110 is successfully changed to the application A ', and the application of the second target server 120 is stopped again.

At this time, if the client terminal 160 makes a service request (3) to the duplication device 135 (S252), the duplication device 135 delivers a service request to the first target server 110 in which the application is running S254), the first target server 110 responds to the service using the changed App A '(S256).

The present embodiment is basically applied when the first target server 110 is the main server and the second target server 120 is the auxiliary server. In general, the performance of the main server is superior to that of the auxiliary server. Therefore, if possible, the main server can be used basically, but the auxiliary server can be selectively used for the application conversion process and the like.

As described above, when using the redundant structure, the non-transient transition occurs. This is also called failover. In other words, if one server is interrupted, it means that it maintains service to another server. There are a lot of technologies that implement this technology in each vendor, and you should check the configuration file to see how to implement them.

In general, when connecting from the outside to the redundant server, the network IP is unified, and when the redundant server 135 of the redundant server system is connected to the redundant server 135 through a single IP, It can be connected to internal IP for delivery. At this time, if the failover occurs, the external IP is still maintained, but only the IP of the server changed to the internal standby is disconnected. Therefore, the service can be maintained by accessing the internal IP of the changed server until the server is restored.

Figure 3 is a diagram illustrating two embodiments of an application change operation in accordance with a redundancy structure.

The second embodiment according to the redundancy structure is an embodiment relating to an operation when an error occurs in the application variation.

This embodiment resumes from the result of Fig. The first target server 110 is in a state in which App A 'to which the variation code is applied is driven (S302). At this time, when the duplication device 135 receives the service request from the client terminal 160 (S304) and transmits the service request to the first target server 110 (S306), an error may occur when driving the App A ' ). When an error occurs, the first target server 110 transmits the service request to the agent unit 130 and reports an error occurrence (S310). The agent unit 130 transmits an App driving stop instruction to the first target server 110 at step S314 and at the same time transmits an application driving instruction to the second target server 120 together with the service request at step S312.

The second target server 120 has a history changed to App A 'and stores App A'. The application A 'is driven again in accordance with the application drive instruction (S316). Accordingly, instead of the first target server 110 in which an error has occurred, the application can be run as App A 'of the second target server 120. In response to the request transmitted together, the second target server 120 performs a service response to the client terminal 160 using App A '(S318). If an error occurs, it is designed to restore to an existing app for more stable operation. The first target server 110 restores to App A before the mutation code is applied (S320). In order to prepare for a situation such as an error, each of the first and second target servers stores application data that has been normally executed. Optionally, only the most recently run successful application data may be stored. As in the present embodiment, the first target server 110 and the second target server 120 store data on the AppA, which has been most recently operated normally, in preparation for the occurrence of an error in the operation of App A '.

When the first target server 110 has recovered to the APP A, it transmits a recovery completion signal to the agent unit 130 (S322). The agent unit 130 transmits an App driving stop instruction to the second target server 120 in step S324 and transmits an App driving instruction to the first target server 110 in step S330. Accordingly, the first target server 110 starts the application A (S330) and the application A 'of the second target server 120 stops the operation (S328).

Thereafter, when the client terminal 160 makes a service request through the duplication device 135 (S332, S334), the first target server 110 responds to the service using the restored application A (S336).

In the above description, it is described that the second target server 120 drives the App A 'to which the mutation code is applied in S316. Optionally, however, the second target server 120 may run App A before the mutation code is applied. This is because, as described below, the first target server 110 is rewritten by App A, and the second target server is also operated by the same App A, which is stable in system operation. That is, instead of driving the App A 'which has an error in the first target server on the second target server, the second target server may also be driven by App A.

In the second embodiment, the first target server, which is a main server, restores the existing app when an error occurs so that the application can be stably driven as a whole. Optionally, however, if an error occurs, instead of restoring to the existing App in the first target server, it may try to convert it back to the App A 'where the error occurred. This process can be performed in a similar process to that described in FIG. If the same error occurs in the conversion process such as providing the mutation code 2-3 times to the first target server in which an error occurs, the agent unit transfers it to the application server, the application server regards this as a serious error, Message.

As shown in FIG. 3, when an error occurs in the application running of the first target server which is the main server, the application of the application of the second target server, which is the auxiliary server, is guided to drive, The overall flow of the server can be done without interruption in application execution and operation.

4 is a diagram showing three embodiments of an application changing operation according to a redundancy structure.

In the third embodiment, unlike the first embodiment or the second embodiment, the first target server and the second target server may both be the main server. That is, the two servers may be the same in terms of performance.

The first target server 110 is in a state in which App A is activated (S402). At this time, the second target server 120 is in a state in which the application is not operated. Accordingly, when the service request is sent from the client terminal 160 to the duplication device 135 (S404), the duplication device 135 delivers the service request to the first target server 110 (S402). The first target server 110 performs a service response using App A, which is an application (S408).

Thereafter, with respect to the application of the mutation code, it can be divided into a first stage and a second stage. In the first stage, App A 'to which the first transition code is applied is driven by the second target server 120, and the first target server 110 is in a state where the application is not driven. The second target server 120 is in a state in which the application A '' applied with the second mutation code generated following the first mutation code is driven by the first target server 110, State.

First, the application server 140 generates a first side code (S410) and provides the first side code to the agent unit 130 (S412). The agent unit 130 confirms that the current application is running in the first target server 110 with App A. After receiving the first mutation code, the agent unit 130 provides the first mutation code to the second target server 120 in which the current application does not operate (S414). The second target server 120 changes some code of the existing stored application to the first variation code, and changes the application to App A '(S416). After the test for normal operation (S418), the result is transmitted to the agent unit 130 (S420), and the agent unit 130 stores the result. In the case of normal driving, the agent unit 130 transmits an application driving instruction to the second target server 120 (S422), and simultaneously transmits an application driving stop command to the first target server 110 (S424). Accordingly, in the first target server 110, the existing application App A is stopped (S428), and the changed target application App A 'is activated in the second target server 120 (S426).

When the client terminal 160 transmits a service request to the duplication device 135 at step S430 because the application is running in the second target server 120, the duplication device 135 transfers the service request to the second target server 120, (S432), and the second target server 120 transmits a service response (S434).

The third embodiment differs from the first embodiment in that there is no process of changing the application from the first target server 110 to App A '. In one embodiment, since the second target server 120 serves as an auxiliary server and the first target server serves as a main server, after the second target server 120 changes to App A ' After changing the target server 110 to App A ', the first target server 110 drives the application, but in the third embodiment, there is no such process.

As a result of the first stage, only App A ', which is an application of the second target server 120, is being driven, and only the App A to which the first mutation code is not applied is stored in the first target server 110 .

If the predetermined time has elapsed, the application server 140 generates a second variation code (S440). The subsequent process is similar to the first process. That is, in the second stage, a second side code is provided to the first target server 110 other than the second target server 120 (S444). Through this, the first target server 110 changes the application to App A '' (S446). The agent unit 130 transmits an App driving instruction to the first target server 110 in step S452 and the second target server 120 in step S452, (S454). Accordingly, App A '' of the first target server 110 is driven (S460) and the application A 'of the second target server 120 is stopped (S462).

As the first and second processes are repeated, the server in which the first target server 110 and the second target server 120 execute the application is repeatedly changed. All such change information is stored in the agent unit 130. Through this process, the present invention can enable the application to continue to run without interruption, while changing the application using the mutation code.

Referring to FIGS. 2, 3 and 4, when the App of one server is driven, the application of the other server is basically stopped. However, optionally, both apps may be designed to operate normally. Both apps may be running on the assumption that all the apps of each server are operating normally. App A 'and App A' running on each server have the same function and operation, and there is no running problem because only the code is different. However, when it is determined that the operation is abnormal, the restoration process is necessary.

5 is a diagram showing a system configuration diagram of an application server and a target server according to a single structure.

A single structure is a structure in which only one server is operated. Unlike the redundancy structure, when the corresponding server is interrupted, the application service is also interrupted.

According to other embodiments of the present invention, a target server according to a single structure may be utilized. In the case of the above embodiments, the case where two or more target servers are used has been described. Alternatively, a single structure having one target server may be used to implement a technology without application interruption.

5 is a diagram showing a system configuration between a target server 520 and an application transition server 530 according to a single structure.

The client terminal 510 can communicate with the target server 520. When the client terminal 510 makes an application related service request, the proxy processing unit 522 of the target server 520 receives the service request. The proxy processing unit 522 can perform a function similar to the duplication apparatus 135 of FIG. The application mutation server 530 is capable of communicating with the agent unit 525 of the target server 520. When the mutation server 530 generates a mutation code for the application and transmits it to the target server 520, And the agent unit 525 of the server 520 receives and processes it.

The target server 520 may receive the mutation code from the application mutation server 530 and may use the mutation code to change some code of the application installed in the target server 520. [ When a request is received from the client terminal, the service is executed using the application, and the corresponding service response is transmitted.

The target server 520 largely includes a proxy processing unit 522, a control unit 542, and a storage unit 526. The target server may be a fixed or mobile terminal.

In the drawing, the agent unit 525 is shown as being included in the control unit 524. [ However, according to another design, the agent unit may be configured as a separate device separate from the control unit.

The proxy processing unit 522 may include one or more modules that enable communication between the target server 520 and the external network or between the target server and the network in which the client terminal is located. The proxy processing unit 522 can transmit and receive various signals such as a service request from the client terminal 510. When the service request is transmitted from the client terminal, the proxy processing unit 522 may determine whether to transmit the service request to the application in the main space or the application in the virtual space, and then transmit the request. Therefore, the proxy processing unit 522 confirms which space application is active or standby.

The control unit 524 controls the overall operation of the target server. For example, the control unit may control various functions of the proxy processing unit 522 and the storage unit 526, as well as the functions of the control unit itself. The control unit 524 can control the execution of the application installed in the target server.

The control unit 524 may optionally include an agent unit 525. The agent unit 525 may be configured separately from the control unit, or alternatively may be included in the control unit.

The agent unit 525 can communicate with the application server 530. When the application server 530 generates a dispatch code for the application, the agent unit 525 receives the dispatch code and controls the application . That is, it checks the state of the application with respect to the mutation code, the position of the driven application, and so on, and controls the overall operation of the application changing operation through the mutation code.

The agent unit 525 may perform functions related to code substitution of multiple applications. A change of the application code or a module is dynamically performed and the application is re-loaded to cause the replacement of the execution process. Depending on the application, there may be a case where the application is restarted after the execution is stopped or the execution is not interrupted There may be cases where only the configuration module can be restarted.

The agent unit 525 can check whether a virtual container exists, whether the application is driven in the corresponding virtual container, whether the application is a version, and the like, which will be described later. In some cases, the agent unit 525 may perform an operation of installing a virtual container when the virtual container is absent. Further, the agent unit 525 may issue an application driving instruction, a stop indication, and the like.

The storage unit 526 may store a program for processing and controlling the control unit, and may perform a function for storing input / output data (for example, a variation code for application code variation) . In addition, an application is installed in the storage unit 526, and the application can be driven in the storage unit. The virtual container 527 may also be included in the storage unit 526. The virtual container 527 can be deleted and generated. As will be described later, the application can be driven in the virtual container 527. [ As a concept distinct from the virtual container, it can be seen that the main space exists in the storage unit 526, and the application can be driven in the main space.

6 is a view for explaining a virtual container structure related to a single structure.

The existing virtualization scheme schematized on the left side of FIG. 6 illustrates the virtualization of the OS using a hypervisor. For example, you can virtualize a Linux operating system (guest OS) on a Windows host operating system to run more than one operating system on a single computer. This method is heavy and slow because the guest operating system occupies the real CPU and memory, so it can not be used in the real operating environment.

To improve this, a new method using the container-based dozer engine shown in the right side of FIG. 6 can be introduced. That is, isolating processes, rather than virtualizing the operating system, has the same effect. An isolated process space is called a container. Containers can be thought of as an aggregate of context information needed for a particular process to run. This is called an image, and images can be copied to different host operating systems to guarantee the same execution.

In summary, a decker, or container virtualization, is one that drives two or more applications in an isolated environment independent of performance. This is equivalent to running the server on two or more computers from the outside.

Describing the present invention, the agent unit 525 can create a virtual container in the target server 520 as needed. In this case, the same effect as using two servers physically like the redundancy server having the redundancy structure described above can be obtained.

A difference occurs in the process of generating and deleting an instance of the virtual container or in the part managing the target application by the agent unit and the intermediary in the communication by the proxy processing unit are additionally mediated.

The virtual container is free to dynamically create and delete, and its extension is also possible. In other words, you can create or reduce multiple server instances while maintaining configuration. You can randomly distribute client requests randomly while replicating multiple applications and maintaining each instance.

7 is a diagram illustrating one embodiment of an application application operation in accordance with a single architecture.

Referring to FIG. 7, an embodiment in which the target server 520 is composed of one will be described.

When the service request for the application is received from the first client, it is responded using App A, which is the first application to which the mutation code is not applied. That is, when the client terminal 510 transmits a service request for the application (S702), the proxy processing unit 522 of the target server 520 delivers the request to the agent unit 52 (S704). The agent unit 525 confirms that the current application A is in a running state, and performs a response to the service using the application A (S706). The service response is transmitted to the client terminal through the proxy processing unit 522 (S710). At this time, App A is being driven in the main space, not in the virtual container.

Hereinafter, an operation of performing a change process for an application will be described.

The application variation server 530 generates a variation code for the application (S712). The generated mutation code is provided to the agent unit 525 (S714). When receiving the mutation code, the agent unit 525 verifies the application information and mutation instructions provided together with the mutation code. The agent unit 525 also confirms the space in which the application related to the variation code is installed. The agent unit 525 confirms whether a virtual container exists in the target server 520 (S716). The presence or absence of the virtual container can be checked by searching the storage unit 526.

If the virtual container 527 does not exist, the agent unit 525 creates a virtual container (S718). In this case, AppA, which is an existing application, is installed together in the virtual container.

As described above, an application can be installed and driven in a virtual container. There is a main space in a space distinguished from a virtual container, and an application is basically installed in the main space, and an application is running.

In the case where the virtual container exists or newly installed, the agent unit 525 changes the existing application App A to the application A 'in the virtual container (S720). App A 'is an application in which App A is changed using the received mutation code. App A and App A 'are functionally the same, but have changed through mutation codes for security. App A and App A 'are the same as most of the codes, so only some codes corresponding to the mutation codes are changed.

In a case where App A is changed to App A 'in the virtual container, the agent unit 525 confirms that the App A' is normally running. That is, it is possible to confirm that the changed application App A 'is operating properly in the virtual container for testing purposes before starting actual operation. Accordingly, only when App A 'is properly operated in the above test, a subsequent process is performed.

That is, when the application is changed by applying the mutation code, the application can be tentatively driven before it is executed to induce the stability of the application operation. As can be seen, while the application of the virtual container is changed to App A ', and the test drive for App A' is in operation, the application running in the entirety of the target server 520 is App A of the main space. Therefore, only when the application A 'passes the test, by performing the subsequent operation, the application change operation can be performed with stability while the application is performing uninterrupted operation. At this time, even if App A 'of the virtual space is normally operated, App A of the main space may be also driven. That is, when the proxy processing unit delivers the service request to the application A 'of the virtual space in operation, the application operation proceeds, so that the application A in the main space does not necessarily have to be stopped.

When AppA is changed to AppA 'in the virtual container, AppA' is present in the virtual container and AppA is present in the main space.

When the test verification of the normal operation of App A 'is successful, the agent unit 525 drives App A' of the virtual container as a subsequent process and stops App A of the main space. At this time, the changed application, App A ', is changed without interruption.

The proxy processing unit 522 and the agent unit 525 take charge of the failover function. That is, the proxy processing unit 522 delivers the service request to the active target application when the application App A of the in-device main space or the virtual container is in the active state. When the proxy processing unit 522 enters the mutation process (application of the mutation code) The target application is changed, the service request is transmitted to the changed target application. The change subject of the target application becomes the agent unit 525. [ That is, the proxy processing unit conducts the network switching according to the activated target application and delivers the service request, and the agent unit changes the target application according to the degree of progress of the application.

The following process will be described with reference to Fig. 8 (a) or Fig. 8 (b).

Figure 8 (a) is a diagram illustrating two embodiments of an application application operation in accordance with a single architecture.

Referring to FIG. 8 (a), the virtual container serves as a temporary standby server space for changing the application of the main space. That is, while the application in the main space is being changed, the application of the virtual container is temporarily activated for uninterrupted drive.

The agent unit 525 changes App A of the main space to App A 'using the variation code (S810). After the change, the agent unit 525 confirms whether the changed App A 'is normally operated (S815). It is a process of testing once again whether it is running normally before driving it into App A of main space. After the normal operation is confirmed, the agent unit 525 drives the App A 'of the main space and stops the App A' of the virtual container (S830). As an optional operation, after suspending App A 'of the virtual container, the agent unit 525 may remove the virtual container (S830).

7 and 8 (a), App A, which is an application in the main space, can be successfully changed to App A 'by applying a mutation code.

Figure 8 (b) is a diagram illustrating three embodiments of application application operations in accordance with a single architecture.

Referring to Fig. 8 (b), the virtual container can continue to be positioned together with the main space. Therefore, the virtual container can perform an equivalent role to the main space. That is, the application of the virtual container is not stopped after the application of the main space is changed. If the application of the main space is changed by applying the mutation code in step 1, the application of the virtual container is changed and driven by applying the mutation code.

8 (b), App A 'of the virtual container is started in S722 of FIG. 7, and App A of the main space is started in an interrupted state. In this case, App A 'is then driven only in the virtual container until a variation code is received.

After a certain period of time, the application server 530 generates a second code (S840). The generated second variation code is provided to the agent unit 525 of the target server 520 (S842).

When the agent unit 525 receives the second variation code, the agent unit 525 confirms the application information and the variation instructions provided together with the second variation code. The agent unit 525 also confirms the place where the application related to the variation code is installed. App A ', the current version of the application, confirms that it is running in a virtual container.

The agent unit 525 changes App A of the main space to App A '' using the second code (S850). That is, the application in the main space is not changed from App A to App A ', and is changed from App A to App A' '. The history information and the like can be stored in the agent unit 525. [

It is confirmed whether the application A '' in the main space is normally operated (S855). If the normal operation is confirmed, the agent unit 525 drives the App A '' of the main space and deactivates the App A 'of the virtual container (S860).

The driven App A " 'can only be driven in the main space until a second variation code, the next change, is provided.

9 is a diagram showing an example of application of a variation code to an application.

In this specification, it has been described that a mutation code is generated by an application mutation server, and the application is continuously changed in the mutation code. This is for application security and is a way to continually replace some of the application's code with mutation code. Through this, it is possible to protect against attempts such as external hacking.

Each of FIGS. 9A, 9B, 9C, and 9D represents one application, which is functionally the same application. That is, supposing that the application of (a) is the application original code, (b) is a case where some code of the application is replaced with a mutation code, and (c) (D) is a case where some code of the application is replaced with the next code.

In the simplest case, each of A, B, C, D, E, F, G, H, I, J, K, L, M, N, The modules of the codes (A, B, C, D), (E, F, G, H), (I, J, K, L) . An example of a module is a function module that can be implemented in an application, such as an authentication module, a communication module, and an input module. The sum of the modules can be viewed as an application.

The present invention is described on the assumption that the code constituting the application is replaced with a variation code. For convenience, (a) can be applied to App A, (b) to App A ', (c) to App A' 'and (d) to App A' ''. Referring to FIG. 9, the original application code of (a) is shown in (b) as A ', B, C, D, E', F, G, H, I, J, K, L ' , And P, respectively. That is, the original codes A, E, and L are replaced with the mutation codes A ', E', and L '. (c), the mutation codes A '', E '', and L '' are substituted. (d), the mutation codes A '' ', E' '', and L '' 'are substituted. Keeping the functionality of your application intact, but it is extremely difficult to analyze your application, even if you analyze code by reverse engineering, if some code in your application changes on a regular or irregular basis.

It is up to the application server to decide which code in the application should be applied as the mutation code.

In the module side, (A, B, C, D), (E, F, G, H) P) is a state in which the mutation code is not applied.

On the other hand, the mutation codes A ', A' ', and A' '' are obfuscated (randomized).

The present invention is applied on the assumption that a mutation code is received from an application mutation server. For details, refer to Korean Patent Application (10-2017-0156035). That is, the application server constantly changes some codes constituting the application, and transmits only the changed code to the target server. The target server changes some code of the application installed on the target server using the changed code.

110 first target server
120 Second target server
130 agent section
140 Application Variant Server

Claims (20)

Operating an agent terminal at a first target terminal, the first application being a first version for a specific application;
The agent terminal receiving a variation code associated with the specific application from an application variation server;
The agent terminal using the mutation code to generate a second application, which is a second version for the specific application, to the second target terminal;
Performing a test operation to determine whether the agent terminal performs normal operation of the second application in the second target terminal; And
And stopping the first application at the first target terminal and the second application at the second target terminal only when the agent terminal performs normal operation during a test operation,
Receiving a service request from a client terminal; And
Further comprising the step of, when the service request is received, the duplicating device sending the service request to the terminal, the first target terminal and the second target terminal,
How to run the application without interruption. The method according to claim 1,
After the agent terminal drives the second application at the second target terminal, generating the second application using the mutation code at the first target terminal;
Performing a test operation to determine whether the agent terminal is normally operating the second application in the first target terminal; And
Further comprising: stopping the second application at the second target terminal and running the second application at the first target terminal only when the agent terminal performs normal operation during the test operation.
How to run the application without interruption. 3. The method of claim 2,
Wherein the agent terminal accesses a service web page URL related to the specific application in the test operation and determines that the application is in a normal operation when an HTTP 404 error is not returned in response to the query.
How to run the application without interruption. 3. The method of claim 2,
Confirming the second application running error at the first target terminal by the agent terminal after the second application is started at the first target terminal; And
Further comprising the step of the agent terminal terminating the second application at the first target terminal and running the second application at the second target terminal.
How to run the application without interruption. 5. The method of claim 4,
Causing the agent terminal to recover the first application at the first target terminal after the second application is run at the second target terminal for the error; And
Further comprising stopping the application at the second target terminal and running the first application at the first target terminal when the agent terminal confirms the recovery of the first application at the first target terminal,
How to run the application without interruption. The method according to claim 1,
Wherein the duplication device confirms information on which of the first target terminal and the second target terminal the specific application is running in,
When the client terminal transmits the service request as a public IP, the redundancy device receives the service request,
Wherein the redundancy device transmits the service request to a target terminal in which the specific application is running among the target terminals as a system internal IP set for each of the target terminals,
How to run the application without interruption. 7. The method according to any one of claims 1 to 6,
Wherein the first application and the second application are different versions of the particular application and the functional operations are the same,
And the second application replaces some code of the specific application with the mutation code.
How to run the application without interruption. 8. The method of claim 7,
The first target terminal is a main server for the specific application,
The second target terminal may be an auxiliary server for the specific application,
How to run the application without interruption. An application variation server for generating a variation code for a specific application;
A first target terminal for running a first application, the first version for the specific application;
A second target terminal; And
And an agent terminal for controlling whether the specific application is driven in the first target terminal and the second target terminal,
The agent terminal,
When the mutation code is received from the application server, generating a second application, which is a second version for the specific application, to the second target terminal using the mutation code,
The second target terminal stops the first application at the first target terminal and controls the second target terminal to start the second application only when the second application performs normal operation in the test operation,
An uninterrupted application-driven system. 10. The method of claim 9,
Further comprising a duplication device for receiving a service request from a client terminal,
The above-
The first target terminal and the second target terminal confirm information of the particular application being driven,
When receiving the service request, transmitting the service request to the target terminal in which the specific application is running,
An uninterrupted application-driven system. 11. The method of claim 10,
When the client terminal transmits the service request to the public IP for the drive system, the duplication device receives the service request,
Wherein the redundancy device transmits the service request to the target terminal in a system internal IP set for each of the target terminals,
An uninterrupted application-driven system. 10. The method of claim 9,
The agent terminal,
Generating the second application by using the mutation code in the first target terminal after driving the second application in the second target terminal,
The second target terminal suspends the second application and controls the first target terminal to drive the second application only when the second application performs normal operation in the test operation,
An uninterrupted application-driven system. 13. The method of claim 12,
The agent terminal controls the test operation as to whether the second application is normally operated in the first target terminal or the second target terminal,
Wherein when the HTTP 404 error is not returned in response to the query by accessing the service web page URL related to the specific application in the test operation,
An uninterrupted application-driven system. 13. The method of claim 12,
The agent terminal,
When the second application driving error occurs in the first target terminal after the second application is driven in the first target terminal,
The first target terminal stops the second application and controls the second target terminal to start the second application,
An uninterrupted application-driven system. 15. The method of claim 14,
After the second application is activated in the second target terminal for the error occurrence, the agent terminal recovers the first application from the first target terminal,
Wherein the agent terminal controls the second target terminal to stop the second application and to drive the first application at the first target terminal when confirming the recovery of the first application at the first target terminal,
An uninterrupted application-driven system. 16. The method according to any one of claims 9 to 15,
Wherein the first application and the second application are different versions of the particular application and the functional operations are the same,
And the second application replaces some code of the specific application with the mutation code.
An uninterrupted application-driven system. 15. The method of claim 14,
The first target terminal is a main server for the specific application,
The second target terminal may be an auxiliary server for the specific application,
An uninterrupted application-driven system. delete delete delete

Images