KR101155123B1 - Apparatus and method for protecting memory of application from failure of kernel code - Google Patents

Abstract

The present invention relates to an apparatus, a method for protecting a memory of an application program from errors of kernel code, and a recording medium for recording the method. The method of protecting a memory of an application program according to the present invention protects some of one or more application programs. Set the target, turn off write access to the application's user address space when the protected application enters kernel mode, and the application's user address when the protected application's kernel mode is turned off. Restore write access to the space.

Description

Apparatus and method for protecting memory of application from failure of kernel code}

The present invention relates to a device and a method for protecting the memory of an application from an error of the kernel code, in particular, a device for preventing the user address space of the application from being invaded by a write command due to the error of the kernel code, A method and a recording medium recording the method.

Recently, the consumer electronics market is growing rapidly with the increasing proportion of embedded system products. Embedded systems are being installed in various types of consumer electronics such as digital TVs and refrigerators. In this market environment, consumer demand for products is changing rapidly, and many manufacturers are trying to launch products that meet the needs of consumers in a timely manner. Embedded systems that perform special functions by embedding software that operates the system in hardware according to the demands of consumers are applied to various devices. Manufacturers are struggling to test and verify the integrity of the device driver for these devices because of the lack of time under the constraint of having timely products to meet consumer demand. At the same time, consumers are still complaining about software bugs found in consumer electronics products. Although some companies are taking product recalls to address software updates or software bugs, their loss of credibility is irreparable.

Device control software, called device drivers, is one of the major causes of system failure. Recently, most consumer electronic products include various devices such as USB controllers and displays, and an operating system of an embedded system includes device drivers for controlling these devices. Many device drivers operate by accessing kernel-level memory space by gaining a privileged level, which can cause serious system errors if a buggy driver accesses this memory space.

The technical problem to be solved by the present invention is to solve the problem of excessive cost when using special hardware or visualization to protect the address space of the application, and difficult to port to various platforms (OS) In order to overcome this problem, main functions of the system cannot be normally performed due to an error in kernel code such as a device driver.

In order to solve the above technical problem, a method of protecting a memory of an application program according to the present invention comprises the steps of setting a portion of one or more application programs to be protected; Releasing write permission for the user address space of the application when the application set as the protection target enters kernel mode, which is the highest level of an operating system; And restoring write permission to the user address space of the application when the kernel mode of the application set as the protection target is released.

In order to solve the above technical problem, a method of protecting a memory of an application according to the present invention includes a function of copying data of a kernel area used in the kernel mode to the user address space of the application during the kernel mode; When called, granting write permission to the user address space that the function is to access; And when the execution of the function ends, releasing write permission for the user address space to which the function accesses.

In order to solve the other technical problem, a method of protecting a memory of an application program according to the present invention comprises the steps of setting a portion of one or more application programs to be protected; Checking whether a physical address of a memory allocated by the application set as the protection target is included in a direct-mapped region; Releasing write permission for the user address space of the application if the physical address is included in the direct-imaging region as a result of the checking; And restoring write permission to the user address space of the application when the direct-imaging region is released.

In addition, the following provides a computer-readable recording medium having recorded thereon a program for executing the methods for protecting the memory of the application program described above on a computer.

In order to solve the above technical problem, an apparatus for protecting a memory of an application program according to the present invention includes a memory for executing the application program; A page table for converting a virtual address of the application to a physical address; A protected target setting unit that sets some of one or more applications as a protected target; And when the application set as the protection target enters kernel mode, which is the highest privilege of the operating system, releases write permission to the user address space of the application, and when the kernel mode of the application set as the protection target is released. And a permission setting unit for restoring write permission to the user address space of the application.

In order to solve the above technical problem, in the device for protecting the memory of the application program according to the present invention, the permission setting unit to the data of the kernel area used in the kernel mode during the kernel mode in the user address space of the application program When the copying function is called, the write permission is given to the user address space to which the function is to access, and when the execution of the function is terminated, the write permission to the user address space to which the function is accessed is released.

In order to solve the other technical problem, an apparatus for protecting a memory of an application program according to the present invention includes a memory for executing the application program; A page table for converting a virtual address of the application program into a physical address; A protected target setting unit that sets some of one or more applications as a protected target; A checker to check whether a physical address of a memory allocated by the application set as the protection target is included in the direct-imaging area; And when the physical address is included in the direct-imaging region as a result of the check, releases the write right to the user address space of the application and writes the user address space to the application address when the direct-imaging region is released. It includes a permission setting unit to recover.

The present invention can selectively protect the user address space of an application from errors of kernel code such as a device driver by releasing and restoring write permission to the user address space of an application set by the user, and furthermore, the main functions of the system. This can be done normally without stopping. In addition, by setting the permissions of the page table through software, no additional hardware or virtualization is required to protect the address space of the application, and as a result, cost reduction and ease of porting to other platforms can be secured.

1 illustrates a memory management system of an operating system operating on a 32-bit x86 architecture.
2 is a flowchart illustrating a method of protecting a memory of an application program from an error of kernel code according to an embodiment of the present invention.
FIG. 3 is a flowchart illustrating a process of exchanging data between a kernel region and a user region in a method of protecting a memory of an application program from an error of the kernel code illustrated in FIG. 2.
4 is a block diagram illustrating an apparatus for protecting a memory of an application program from an error of kernel code according to an embodiment of the present invention.
5 is a flowchart illustrating a method of protecting a memory of an application program from an error of kernel code according to another exemplary embodiment of the present invention.
6 is a block diagram illustrating an apparatus for protecting a memory of an application program from an error of kernel code according to another embodiment of the present invention.

Prior to describing embodiments of the present invention, basic ideas are introduced to protect memory space from illegal access of a faulty device driver.

In general, most of the memory space protection techniques focus on protecting the kernel because an application error is not propagated to other applications or the kernel. However, in the case of consumer electronics, ensuring the reliability of a core application is just as important as the reliability of a kernel. For example, in a portable media player (PMP), the media player is the device's most important core application. If a bug in the device driver invades the memory associated with the media player, the media playback service, which is a major feature of PMP, will not work properly. In general, in the case of consumer electronic devices, when the main functions do not operate normally, the user's dissatisfaction is very large, so the core application must be protected to maintain the functionality of the device.

Even though some errors exist in the application, most of the reliability issues have been related to the context of the kernel in the past, because the entire system is often not very harmful. With the recent advent of kernel extension technology and the inclusion of various device drivers in the kernel, these reliability issues have become more interesting. Well-known methods to improve the reliability of the system have also suggested ways to isolate the components of the system.

One method used to isolate device drivers is virtualization. Each virtual machine (VM) has its own address space and cannot directly access the address space of different virtual machines. Because of this nature, entire kernel components, including device drivers, can be isolated. Although this isolation technology has effectively prevented the spread of errors in computer hardware, virtualization technology has incurred excessive costs for implementation. Much of this cost comes from attempts by the isolation technology to protect kernel objects from access by other kernel code. In particular, since these kernel objects all reside in the same address space, all memory accesses must be validated, resulting in excessive costs.

Another method used to isolate device drivers is hardware-based protection. This method protects memory from invalid access through special hardware. However, although this hardware approach can effectively protect memory and show good performance, most consumer electronics do not have the performance or environment to have such specially designed hardware. Accordingly, embodiments of the present invention seek to take a different approach than the methods described above.

Hereinafter, a description will be given of how a memory management task is performed in an operating system with reference to FIG. 1. 1 is a diagram illustrating a memory management system of an operating system operating in a 32-bit x86 architecture, and illustrates an x86 processor for convenience of describing memory management.

In a 32-bit addressing system, the processor can access virtual memory addresses of 4 GB in size. On the other hand, the address space can be divided into two types, the first is the lowest address space is called the user address space (user address space) (132). Typically, user address space 132 is allocated 2 GB to 3 GB of space, and every process has its own copy of the address space. The second is the topmost address space 131 allocated for the kernel, where data and codes used in kernel mode are stored. Unlike the user address space 132, there is only one kernel address space in the address space 131 for this kernel mode, and only privileged processes can access this space directly. The kernel treats pages as a basic unit of memory management, and virtual addresses (meaning logical addresses) are translated into physical addresses through page tables 121 and 122.

Meanwhile, the 'user page table 122', also called 'process page table', maps user addresses to specific physical addresses. When the CPU refers to a physical page via a virtual address, the corresponding page table 122 is tracked to check the access rights of the page. If access is valid, the CPU reads the page through the translated physical address.

The kernel also has a page table 121 called 'kernel page table' or 'master kernel page global directory'. Most kernel addresses are mapped to physical addresses directly by the kernel page table 121. For example, the operating system can map linear kernel addresses from 0xc0000000 to 0xf7ffffff as physical addresses from 0x00000000 to 0x37ffffff. A direct mapping method that translates addresses in this simple way can improve the performance of address mapping. Similarly, the CPU can access kernel space in the same way as user page tables.

The address management system, on the other hand, allocates available physical pages when a process requests page allocation, and generates a map through the user page table. If the address of an allocated physical page is mapped directly to a kernel virtual address, the physical page can be mapped to kernel space as well as user space even though the kernel virtual address is not assigned to any kernel component. In FIG. 1, the kernel uses an area from 0xc0000000 of the total 4GB of virtual memory (meaning a space from upper 3GB to 4GB). This area is directly mapped to the physical memory 110 areas 0B to 896MB. ) In other words, accessing a 1MB area of physical memory is the same as accessing a 3GB + 1MB area of virtual memory.

In this case, if the kernel exclusively uses the 0B to 896MB of physical memory, no problem occurs. In practice, however, a problem arises because the kernel does not only use the area but also uses the 0B to 896MB area of the same physical memory in the user area. That is, areas 0B to 896MB of the physical memory may be kernel areas and user areas. This structure (meaning direct mapping structure), when the failed kernel writes data to the kernel area, this results in the data being written to the user area as well as the kernel area. Can cause fatal problems. In other words, since kernel space and user space in memory share a physical address, accessing the kernel virtual address means that it can invade the user virtual address.

In FIG. 1, although the kernel address space 131 and the user address space 132 each have their own regions shown in black in the virtual address space, it is assumed that the regions have a directly mapped structure. Accordingly, when the virtual addresses of the kernel and the user address space are converted into the physical addresses through their page tables 121 and 122, respectively, the same addresses may be indicated on the physical memory 110. Therefore, if a write command is generated due to an error in the corresponding address space in kernel mode, the same physical space used by the user application may be invaded. As a result, the memory of the application program may be damaged by a malfunctioning device driver in the memory management system of FIG. 1.

Hereinafter, a description will be given in more detail of the situation (threat model) in which the core application process is invaded by the kernel code, and the method of protecting such an application through an embodiment of the present invention. The basic idea of embodiments of the present invention is to use a memory management unit (MMU) to protect the core application software from invalid write operations to the application's memory. Most embedded processors provide two mechanisms for accessing the application's memory space. One is through a memory management unit and the other is through direct memory access (DMA). Instructions stored in the device driver code may violate a portion of the application address space. A DMA-based approach is necessarily performed through the DMA subsystem in the kernel, thus threatening the situation by device drivers assumed by embodiments of the present invention. Does not fit. Therefore, the following description focuses on the memory management unit excluding the DMA approach.

The first situation where a core application process is invaded by kernel code is the case of writing to the user address space. In kernel mode, a process has the privilege of accessing any memory space, and the device driver is driven by a system call or hardware interrupt from a user application. If there is an error in the address calculation during the initialization of the drive, the device driver code will access the wrong location, which may be a location in the physical page belonging to the user application. The application is then in an insecure state in performing its original function. In order to alleviate this unsafe condition, embodiments of the present invention provide the following technical means having a low technical cost to be utilized in various user appliances.

Since most memory protection technologies require kernel coding, complex mechanisms can be expensive to apply to a variety of embedded platforms. Although protecting kernel objects from illegal access by other kernels requires a complex mechanism, the address space of a user application is relatively easy to protect. This is because the address space of the user application is separated from the kernel space. Accordingly, embodiments of the present invention have focused on a memory management system.

Embodiments of the present invention can set up write-protection for page table entries so that false access of the kernel can be detected with very little overhead. In addition, the applications to be protected may be differentially selected according to the user's protection needs, the scope of protection and the level of efficiency. In particular, embodiments of the present invention can be readily implemented by modifying common operating systems employed in many embedded systems. Since most operating systems have similar memory management systems, it is possible for other embedded systems to apply embodiments of the present invention without any difficulty.

First of all, an embodiment of the present invention to be introduced is called a "user address space protection" method. The user address space protection method protects the application space from kernel write operations. Writing from kernel code occurs only when the kernel code is driven by a system call or an interrupt. When the process enters kernel mode, the memory management system of this embodiment releases the kernel's write permission to all user address spaces by changing the permission bits of each page table entry. If dangerous kernel code attempts to write to the user address space, the page table will not contain any permission bits, so writing attempts to these kernel code will fail. After that, when the kernel completes its work and the suspended user process resumes, the write permission will be restored from 'prohibit' to 'permit' again.

The kernel tries to read data from or write data to the user address space to communicate with the application. For example, a read system call copies kernel memory content that must be read from a file, network, or pipe into the user address space. Similarly, a write system call copies data resident in the user address space into the kernel address space.

Thus, according to the embodiment of the present invention described above, since the read permission has not been changed, a read operation from the user address space may be normally performed. However, even if the write operation is permitted for correct kernel operation, the write operation to the user address space will be rejected according to the embodiment described above. Therefore, if the write operation is valid, the forbidden write permission on the target address needs to be restored. In other words, it is necessary to grant the write permission again to perform a valid write operation normally. Further, when this valid write operation is terminated, the target address is preferably reprotected.

Protection based on the user address space protection method must be set before the kernel code runs. Thus, when a system call occurs, the protection function is called before the system call handler. If the current process is to be protected, the protection must keep track of all page table entries to release write access. Finally, when the system call ends, the write permission is restored.

When the kernel code is running, valid write operations must be allowed as described above. Therefore, it is necessary to know which pages are writeable. Commonly known Unix or Linux based systems require the exchange of data between user and kernel space. A typical example is a case of passing a variable / argument by a system call. Since the user memory is not directly accessible in the kernel area, the data in the user area should be copied to the kernel area. Functions such as 'get_user ()', 'put_user ()', 'copy_from_user ()', and 'copy_to_user ()' are used for this task. Among these, 'get_user ()' and 'copy_from_user ()' functions are used to copy from user space to kernel space, and 'put_user ()' and 'copy_to_user ()' functions are used to copy from kernel space to user space. do. Therefore, in the present embodiment, a variable such as 'put_user ()' and 'copy_to_user ()' will attempt to copy a variable in the kernel area to a user area (meaning a variable area of an application program).

However, embodiments of the present invention have a write permission released by the protection function. Thus, it is desirable to allow usage rights for pages that map addresses to be written to ensure that these functions operate correctly when the specific functions described above are executed. In other words, after completing the operation by granting the released permission, the pages are reprotected when the functions are terminated.

FIG. 2 is a flowchart illustrating a method of protecting a memory of an application program from an error of kernel code according to an embodiment of the present invention, and illustrates the user address space protection method introduced above.

In step 210, some of the one or more applications are set as protection targets. In this case, the application set as the protection target may be differentially selected by considering at least one of a function of an application program, a user's protection request, a protection range, and a protection efficiency level among the one or more applications.

In step 220, when the application set as the protection target in step 210 enters kernel mode, which is the highest privilege of the operating system, by a system call or interrupt, the write permission of the application's user address space is released. . Specifically, the step of releasing write permission traverses the page table of the application and changes the permission bits for write permission of page table entries for all user address spaces. Disable the write operation of the kernel.

The kernel mode operation is performed in step 230 with write permission released, and the operation enters step 240 when the operation is completed.

In step 240, when the kernel mode of the application set as the protection target is released in step 210, the write permission on the user address space of the application is restored. Similarly, changing the permission bit of the application's page table entry allows the kernel to write to all user address spaces.

FIG. 3 is a flowchart illustrating a process of exchanging data between a kernel region and a user region in a method of protecting a memory of an application program from an error of the kernel code illustrated in FIG. 2, and focusing on authorization processing by a function call. I will explain.

In step 235 of FIG. 3, it is checked whether a specific function is called while the kernel mode is in progress. Here, the specific function refers to a function that copies the data of the kernel area used in the kernel mode to the user address space of the application, and may be a function such as put_user () 'and' copy_to_user () '.

As a result of the check, if a specific function is called, step 310 is entered. In step 310, write permission is given to the user address space to which a specific function is to be accessed, and then, in step 320, the function is executed. Subsequently, when execution of the function is terminated in step 330, the write permission for the user address space accessed by the function is released.

FIG. 4 is a block diagram illustrating an apparatus 400 for protecting a memory of an application program from an error of a kernel code according to an embodiment of the present invention, which corresponds to the embodiment of FIG.

The memory 410 loads necessary pages of the application program to execute the application program 450. The page table 420 converts the virtual address of the application 450 into a physical address. Such a configuration is basically a configuration that a memory management system should be provided, and is obvious to those skilled in the art.

The protection target setting unit 430 sets some of one or more application programs as protection targets. As described above, it is preferable that a core application program that performs the most important function in an environment in which an embodiment of the present invention is implemented is a target of protection, but it is possible to set various application programs as targets of protection according to the implementation environment.

The permission setting unit 440 releases write permission on the user address space of the application when the application set as the protection target by the protection target setting unit 430 enters the kernel mode, which is the highest permission of the operating system. Restore write permission when kernel mode is released again. In addition, the permission setting unit 440 grants write permission to the user address space that the function will access when a specific function is called during kernel mode, and the user address accessed by the function when execution of such a function is terminated. Turn off write access to the space.

The protection target setting unit 430 and the authority setting unit 440 may be implemented through a processor capable of processing a series of operations and a memory required to record data according to these operations. Such a processor and a storage space may be appropriately selected by those skilled in the art in consideration of the utilization environment or operating environment of the technical field to which the present invention belongs. Furthermore, this process may also utilize additional software code for controlling the hardware illustrated above.

According to the embodiments of the present invention described above, the user address space of the application can be selectively protected from an error of kernel code such as a device driver by releasing and restoring write permission to the user address space of the application set by the user. In addition, the main functions of the system can be performed normally without stopping. In addition, by setting the permissions of the page table through software, no additional hardware or virtualization is required to protect the address space of the application, and as a result, cost reduction and ease of porting to other platforms can be secured.

Let's look at the second situation (in the case of writing through direct mapping) where the core application process is intruded by kernel code. As described above with reference to FIG. 1, when physical pages are mapped to both the kernel and the application program, direct mapping of the kernel may also cause unauthorized access from device drivers. Buggy device drivers can allow incorrect access to mapped pages in the application as well as the kernel. Thus, if the kernel address is a dual mapped physical address (meaning that the address is mapped in kernel space and user space together), writing to the kernel address can affect the user address.

This direct mapping is particularly dangerous because it can affect all processes in the system. In the first case described above, the kernel could only access the process with the current context, while the directly mapped memory could be mapped to the user address space of any process, so that the kernel code has nothing to do with the current system state. This can adversely affect a process that is missing.

A second embodiment of the invention, which will be introduced below, is termed a "direct-ideal protection" method. Direct-imaging protection protects user space from kernel writes when a kernel write request occurs through direct mapping. This direct-imaging protection method is driven when the page allocator of the memory management system maps the physical address from the direct mapping area to the user address. Direct-imaging protection releases write access to the page when this address mapping is complete. Thus, if a process in the kernel attempts to write to a protected kernel virtual address, an exception error will occur and the write attempt will be blocked. When the mapping for this user virtual address is released, the write permission is restored again.

To implement direct-ideal protection for a typical operating system, you only need to add a few lines of code to the functions for page allocation and free. When an application requests page allocation, the kernel allocates a physical page. If the physical page is located in a directly mapped memory region, the direct-imaging protection method finds a kernel virtual address mapped to a physical address. The present embodiment then deprives the write permission of the page table entry containing this address. Subsequently, when the allocated page is released, the write permission of the kernel page table entry is restored.

FIG. 5 is a flowchart illustrating a method of protecting a memory of an application program from an error of kernel code according to another embodiment of the present invention, and illustrates the direct-imaginary protection method introduced above. In this embodiment, the application program makes a memory allocation request, and the memory management unit determines a memory page to allocate according to the request.

In operation 510, some of the one or more applications are set as protection targets. Since this process is similar to step 210 of FIG. 2, a detailed description thereof will be omitted.

In step 520, the application set as the target of protection in step 510 determines whether the physical address of the allocated memory is included in the direct-mapped area. If the case proceeds to step 530.

In operation 530, the write permission of the user address space of the application is released. Specifically, the step of releasing the write permission prohibits the kernel writing operation to the user address space by changing the permission bit of the page table item (meaning the kernel direct mapping map) of the application.

The flow now proceeds to step 540 to allocate memory and perform tasks. When the operation is complete, the memory is returned.

In step 550, when the direct-imaging region is released, write permission to the user address space of the application is restored. Similarly, restoring write permission allows the kernel's write operation to the user address space by changing the permission bits of the application's page table entries.

If it is determined in step 520 that the physical address of the memory allocated by the application program is not included in the direct-imaging region, the process proceeds directly to step 560 to perform a task.

FIG. 6 is a block diagram illustrating an apparatus 600 for protecting a memory of an application program from an error of a kernel code according to another embodiment of the present invention, and thus a detailed description thereof will be omitted.

The memory 610, the page table 620, and the protection target setting unit 630 correspond to similar configurations to the memory 410, the page table 420, and the protection target setting unit 430 of FIG. 4, respectively.

The checker 660 checks whether the physical address of the memory allocated by the application set as the protection target by the protection target setting unit 630 is included in the direct-imaging region. In FIG. 6, the inspection unit 660 is illustrated in the authority setting unit 640. However, since the inspection unit 660 is provided as an example of the implementation, it is obvious that the inspection unit 660 may be modified and implemented in various structures by those skilled in the art. .

The permission setting unit 640 releases the write permission of the application address space of the application when the physical address is included in the direct-imaging region and the user of the application when the direct-imaging region is released. Restore write access to the address space. Specifically, the permission setting unit 640 prohibits or allows the kernel's write operation to the user address space by changing the permission bit of the page table item of the application.

The inspection unit 660, the protection target setting unit 630, and the authority setting unit 640 may be implemented through a processor capable of processing a series of operations and a storage space necessary for recording data according to these operations. Such a processor and a storage space may be appropriately selected by those skilled in the art in consideration of the utilization environment or operating environment of the technical field to which the present invention belongs, and additional software code for controlling the hardware illustrated above. May also be utilized.

According to the embodiments of the present invention described above it is possible to selectively protect the user address space of the application from the error of kernel code, such as a device driver, furthermore, the main function of the system can be performed normally without stop, No extra hardware or virtualization is required to protect the address space, which reduces cost and eases porting to other platforms.

Meanwhile, the present invention can be embodied as computer readable codes on a computer readable recording medium. The computer-readable recording medium includes all kinds of recording devices in which data that can be read by a computer system is stored.

Examples of computer-readable recording media include ROM, RAM, CD-ROM, magnetic tape, floppy disks, optical data storage devices, and the like, which may also be implemented in the form of carrier waves (for example, transmission over the Internet). Include. The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion. In addition, functional programs, codes, and code segments for implementing the present invention can be easily deduced by programmers skilled in the art to which the present invention belongs.

The present invention has been described above with reference to various embodiments thereof. It will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. Therefore, the disclosed embodiments should be considered in an illustrative rather than a restrictive sense. The scope of the present invention is shown in the claims rather than the foregoing description, and all differences within the scope will be construed as being included in the present invention.

110: physical memory
121: Kernel Page Table 122: User Page Table
131: kernel address space 132: user address space
400, 600: computer system
410, 610: memory 420, 620: page table
430, 630: protection target setting unit 440, 640: authority setting unit
450, 650: application
660: inspection unit

Claims (15)

In the method of protecting the memory of the application,
Setting some of the one or more applications to be protected;
Releasing write permission for the user address space of the application when the application set as the protection target enters kernel mode, which is the highest level of an operating system; And
Restoring write permission to the user address space of the application when the kernel mode of the application set to be protected is released. The method of claim 1,
Granting write permission to a user address space to which the predetermined function is to access if a predetermined function is called during the kernel mode; And
When the execution of the predetermined function ends, releasing write permission for the user address space to which the predetermined function accesses. The method of claim 2,
Wherein the predetermined function is a function for copying data of a kernel area used in the kernel mode to a user address space of the application program. The method of claim 1,
The step of releasing the write permission prohibits the kernel from writing to all user address spaces by changing the permission bits of the page table entries of the application.
And restoring the write permission to allow the kernel to write to all user address spaces by changing the permission bits of the page table entry of the application. The method of claim 1,
The application set as the protection target may be differentially selected by considering at least one of a function of an application, a protection request of a user, a protection range, and a level of protection efficiency among the one or more applications. In the method of protecting the memory of the application,
Setting some of the one or more applications to be protected;
Checking whether a physical address of a memory allocated by the application set as the protection target is included in a direct-mapped region;
Releasing write permission for the user address space of the application if the physical address is included in the direct-imaging region as a result of the checking; And
Restoring write permission to the user address space of the application when the direct-imaging region is released. The method according to claim 6,
The step of releasing the write permission prohibits the kernel from writing to the user address space by changing the permission bit of the page table entry of the application,
And restoring the write permission to allow the kernel's write operation to the user address space by changing the permission bits of the page table entry of the application. The method according to claim 6,
The application set as the protection target may be differentially selected by considering at least one of a function of an application, a protection request of a user, a protection range, and a level of protection efficiency among the one or more applications. A non-transitory computer-readable recording medium having recorded thereon a program for executing the method of claim 1. In a device for protecting the memory of the application,
A memory for executing the application program;
A page table for converting a virtual address of the application to a physical address;
A protected target setting unit that sets some of one or more applications as a protected target; And
When the application set as the protection target enters kernel mode, which is the highest level of the operating system, releases write permission to the user address space of the application, and when the kernel mode of the application set as the protection target is released. A device that includes a permission setter that restores write access to the user address space of the application. 11. The method of claim 10,
The permission setting unit grants write permission to a user address space to which the predetermined function accesses when a predetermined function is called during the kernel mode, and accesses the user address space to which the predetermined function accesses when execution of the predetermined function ends. And disabling write permission for the device. The method of claim 11,
And the predetermined function is a function for copying data of a kernel area used in the kernel mode to a user address space of the application program. 11. The method of claim 10,
And the permission setting unit prohibits or allows the kernel to write to all user address spaces by changing the permission bits of the page table entry of the application. In a device for protecting the memory of the application,
A memory for executing the application program;
A page table for converting a virtual address of the application program into a physical address;
A protected target setting unit that sets some of one or more applications as a protected target;
A checker to check whether a physical address of a memory allocated by the application set as the protection target is included in the direct-imaging area; And
If the physical address is included in the direct-imaging region as a result of the checking, the write permission of the user address space of the application is released and the write permission of the application address space of the application is released when the direct-imaging region is released. Device including a permission setting to recover. 15. The method of claim 14,
And the permission setting unit prohibits or permits a kernel write operation to a user address space by changing a permission bit of a page table entry of the application program.

Images