KR102493066B1 - Fine-grained isolation to protect data against in-process attacks - Google Patents

Abstract

In the AArch64 architecture, a fine-grained isolation technique for counteracting intra-process attacks is disclosed. A data isolation method for counteracting an attack inside a process performed by a data isolation system includes: executing a code for which an encryption key is assigned through a memory usage right in an architecture of a computer processor; and controlling access to sensitive data of the access-allowed code using the assigned encryption key while the access-allowed code is being executed.

Description

Fine-grained isolation technology to counter process internal attacks {FINE-GRAINED ISOLATION TO PROTECT DATA AGAINST IN-PROCESS ATTACKS}

The following description relates to a method and system for counteracting an intra-process attack in an architectural environment of a computer processor.

Many software attacks attempt to steal or tamper with security-sensitive data (for example, key data such as encryption keys, passwords, and certificates) existing in running programs (processes). These attacks achieve their goals by exploiting flaws such as bugs and vulnerabilities in programs to obtain the same memory access privileges as programs with sensitive data. To counter this, the first strategy that can be considered is to remove the coupling that exists in the program so that attackers cannot exploit it, but in light of the findings that even carefully designed programs by experts contain flaws in proportion to their code size, this is almost impossible to achieve Therefore, as a practical strategy for improving program security, it is widely adopted to apply the principle of privilege separation, which allows only authorized codes to access necessary data, from the program design stage. Currently, the representative way to implement this is to separate sensitive data and code that is allowed access to it into separate operating system processes. Since each process is blocked from accessing memory by the inter-process memory isolation mechanism supported by the operating system, access to sensitive data is blocked except for the designated process.

However, sensitive data isolated using the process is also vulnerable to attacks using vulnerabilities that occur within the "same process." In order to cope with the class of attacks classified as in-process attacks, a fine-grained data isolation technique that allows developers to allow access to sensitive data to only a portion of the entire code in the process is required. It is essential. The core of the fine-grained data isolation technique is that it should be possible to grant different memory access rights between codes within the same process that have been granted the same memory access rights by the operating system. To realize this, the non-patent document "Shreds: Fine-grained execution units with private memory, IEEE Symposium on Security and Privacy, pp. 56-71, 2016" designed as the most recent study is based on the ID assigned to the memory area. A memory domain, which is an ARM hardware function that allows access control to a specific memory area, was used. Specifically, first, a unique domain ID is assigned to the private area, and a domain access control register is set that determines the access authority of the access area of the memory area associated with the domain ID according to whether or not code permitted to access the area is running. to allow or deny access to the private region. ARM's memory domains made it possible to isolate multiple individual pairs of data and code from each other with minimal performance cost.

However, memory domain functions exist only in ARM's 32-bit architecture (AArch 32) and are not available in ARM's 64-bit architecture (AArch 64), which is widely used today in the market for high-end and low-end mobile devices. Accordingly, it is not applicable in AArch64, and since the memory domain of ARM eventually operates under the management of the operating system (OS) kernel, the kernel must intervene whenever access to sensitive data is requested, consuming thousands of CPU cycles. There is a problem with doing it.

We intend to implement a sealer, a granular data isolation function, so that only permitted codes can access sensitive data based on an encryption key, and provide the implemented function in the form of an API.

A data isolation method for counteracting an attack inside a process performed by a data isolation system includes: executing a code for which an encryption key is assigned through a memory usage right in an architecture of a computer processor; and controlling access to sensitive data of the access-allowed code using the assigned encryption key while the access-allowed code is being executed.

The step of executing the access-allowed code may include determining important data related to the access-allowed code, assigning an encryption key to the access-allowed code, and linking the important data and data through the assigned encryption key. It may include encrypting relevant sensitive data.

In the step of executing the access-allowed code, areas accessible to the important data within a thread executed in a process of the architecture of the computer processor are classified into entry gates and exit gates. steps may be included.

The entry gate loads an encryption key assigned to the access-allowed code, and an authentication token is issued when the access-allowed code is input to the entry gate, and the exit gate loads the assigned encryption key and the issued authentication token may be deleted.

The architecture of the computer processor includes ARM's AArch64, and the memory usage right includes XnR (Execute-no-Read) introduced in AArch64, which reads the assigned encryption key to the access-allowed code. When the command is executed, the allocated encryption key can be protected by loading the allocated encryption key into the code for which the access is permitted.

In the controlling step, as a thread is executed in the architecture of the computer processor, the entry gate of the code for which access is allowed is reached, and both the encryption key and the authentication token assigned to the code for which access is allowed are loaded into the entry gate. According to this, the access-allowed code accesses the encrypted important data using the assigned encryption key, and when the access is terminated, deletes the assigned encryption key and authentication token from the exit gate, and executes the thread It may include a step of maintaining.

In the controlling step, based on identification information allocated to a private region including a plurality of codes and important data, codes to which access is allowed are assigned to a private region having the same identification information, respectively. It may include sharing data.

An operation performed by the data isolation method may be provided as an API.

The data isolation system includes: a code execution unit that executes a code to which an encryption key is assigned access is allowed through a memory usage right in the architecture of a computer processor; and an access control unit controlling access to sensitive data of the access-allowed code using the assigned encryption key while the access-allowed code is being executed.

The code execution unit may determine important data related to the access-allowed code, allocate an encryption key to the access-allowed code, and encrypt the important data related to the important data through the assigned encryption key. there is.

The code execution unit may classify areas accessible to the important data within a thread executed in a process of the architecture of the computer processor into entry gates and exit gates.

The entry gate loads an encryption key assigned to the access-allowed code, and an authentication token is issued when the access-allowed code is input to the entry gate, and the exit gate loads the assigned encryption key and the issued authentication token may be deleted.

The architecture of the computer processor includes ARM's AArch64, and the memory usage right includes XnR (Execute-no-Read) introduced in AArch64, which reads the assigned encryption key to the access-allowed code. When the command is executed, the allocated encryption key can be protected by loading the allocated encryption key into the code for which the access is permitted.

The access control unit reaches the entry gate of the access-allowed code as the thread is executed in the architecture of the computer processor, and both the encryption key and the authentication token assigned to the access-allowed code are loaded into the entry gate. When the access allowed code accesses important data encrypted using the assigned encryption key, and when the access is terminated, the assigned encryption key and authentication token are deleted from the exit gate, and the thread execution is terminated. can keep

The access control unit, based on identification information assigned to a private region including a plurality of codes allowed for access and important data, assigns the code to which access is permitted to a private region having the same identification information, and the important data can share.

Security can be improved by dramatically reducing the possibility of access to sensitive data by applying the principle of privilege separation, which allows only authorized code to access necessary data, from the program design stage.

By providing developers with a fine-grained data isolation function in the form of an API so that only permitted code can access sensitive data, developers can freely use Sealer.

1 is a diagram for explaining a general data isolation operation of a sealer according to an embodiment.
2 is a diagram for explaining a process of developing a sealer for data isolation according to an embodiment.
3 is a diagram for explaining a management system for access-allowed codes and personal areas, according to an embodiment.
4 is an example for explaining an entry gate according to an embodiment.
5 is a diagram for describing an operation of accessing a private memory according to an exemplary embodiment.
6 is an example for describing an exit gate according to an embodiment.
7 is a block diagram illustrating a configuration of a data isolation system according to an exemplary embodiment.
8 is a flowchart illustrating a data isolation method for responding to an attack within a process, according to an exemplary embodiment.

Hereinafter, an embodiment will be described in detail with reference to the accompanying drawings.

An embodiment is to provide a granular data isolation function so that only permitted code can access sensitive data based on an encryption key in a computer processor architecture. The computer processor may be a RISC processor widely used in embedded devices. For example, it may include ARM's 32-bit architecture (AArch32) or 64-bit architecture (AArch64).

In an embodiment, the operation of implementing a sealer to provide efficient data isolation in AArch64 while overcoming the lack of hardware support for memory isolation will be described. Sealers can be implemented by combining hardware features present in AArch64.

1 is a diagram for explaining a general data isolation operation of a sealer according to an embodiment.

Multiple threads can run inside a process, which is assumed to have its own thread-level protection mechanism. The purpose of sealers is to protect threads (especially sensitive data) with an additional mechanism against in-process/thread attacks.

As the thread executes, it may reach the entry gate of the code to which it has been granted access (1). The two important roles of the entry gate are loading cryptographic keys and generating authentication tokens to satisfy the sealer's two security properties. Encryption keys used by code that has been granted access can grant exclusive access to sensitive content stored encrypted in a private region. If code attempts to read or write private content in a thread without a valid encryption key, it may crash or produce unpredictable results. Authentication tokens can be used to verify atomic execution of code that has been granted access. Authentication tokens are issued only when the code is entered through the entry gate, so Sealer can detect an attempt to jump to the code without going through the entry gate simply by checking for the presence of the token. When both the encryption key and authentication token are loaded into the entry gate, code that is granted access has exclusive access to sensitive data (2). When the access-allowed code terminates, the exit gate clears the security risk state, such as the encryption key and authentication token generated by the entry gate, and keeps the thread running (3).

2 is a diagram for explaining a process of developing a sealer for data isolation according to an embodiment.

Figure 2 describes the development process of an application using Sealer to facilitate the implementation of data isolation. The only requirement for the application developer is to use the sealer API at the source code level to define what is isolated: the code that has access to access sensitive data and the memory block that will contain the sensitive data. Executables augmented with the sealer API can be loaded into the system and executed. At this point, Sealer's loader provides kernel-level support for enforcing Sealer's data isolation, such as configuring execute-only permissions.

3 is a diagram for explaining a management system for access-allowed codes and personal areas, according to an embodiment.

In an embodiment, sealer, which is a fine-grained data isolation technique available in AArch64, may be implemented. Sealer responds to arbitrary access by encrypting the value of sensitive data. The sealer must be able to detect and stop any attempts to tamper with the flow of execution to externally authorized code to ensure data isolation, and ensure that the private domain has access only to code that has been granted access to it.

More specifically, pairs of sensitive data and accessible codes are first determined and a unique encryption key is assigned to each. Code that is granted access exclusively possesses a single encryption key, giving it access to encrypted sensitive data while executing the code. In order to implement Sealer, it is necessary to provide a solution for how to safely protect the encryption key. To solve this problem, we want to use the memory usage right called XnR (Execute-no-Read) newly introduced in AArch64. It protects the key inserted through XnR and provides a function to allocate a separate key for each code allowed to access important data. XnR is used to prevent exposure of security-critical code such as firmware by malicious memory access. In the embodiment, it is applied that an encryption key can be effectively protected through a process of embedding data in a code and protecting the code through XnR. Through this, Sealer can safely realize granular data isolation based on encryption techniques in AArch64 based on the structure shown in FIG. 3 .

Before explaining the Sealer API, we will first explain the details of Sealer's management system for code and private areas that are allowed access. As shown in Figure 3, Sealer can support multiple pairs of allowed code and private domains. Identification information (ID) can be assigned at development time in code and private areas where all access is allowed. Sealer assigns an encryption key to each accessible code and private area according to a given ID at runtime, so that each accessible code is paired with a private area with the same ID. Codes with some access granted can have the same ID, in which case all codes can be paired with the same private area and share the same sensitive data. However, since each access allowed code can have only one ID, it cannot be paired with multiple personal areas. The personal area is composed of important data sets, and important data can be dynamically added to or deleted from the personal area through codes that allow access related to the personal area.

To support the management system described above, Sealer can provide developers with four APIs. The sealer API is an API that designates the start and end points of codes that are allowed to access important data, and is an API that allows access to important data based on a protected encryption key. First, two APIs can be provided to define codes that are allowed to access during development. Application developers can use Sealer_start and Sealer_end to indicate the start gate and end gate of each access-allowed code. The number (ID) passed as a parameter of sealer_start can be used to identify each access-allowed code. Second, Sealer_encrypt and Sealer_decrypt can be provided to developers for encryption and decryption of important data protected by sealer.

A sealer's loader is a component of sealer that runs in the kernel to handle tasks that can only be done at the kernel level. When a program with a sealer runs on a system, it can intervene to assign encryption keys and authentication tokens to code that has been granted access. Sealer's loader can first generate an encryption key and a random authentication token and insert them as part of the code it has access to. After that, it is possible to protect cryptographic keys from attackers without appreciable performance degradation at runtime by activating execution-only privileges on entry gates, memory regions of exit gates, and code that is allowed access. Another role of Sealer's loader is to protect secrets stored in registers, such as encryption keys, from being exposed outside the code. Sealer ensures that if code with access is running when the signal is delivered, Sealer's loader backs up registers in the kernel and invalidates them so that they are not exposed to attackers during signal processing. When the signal processing is complete and the allowed code returns, the sealer restores the previous values of the registers so that the allowed code execution can continue correctly.

4 is an example for explaining an entry gate according to an embodiment.

At the entry gate, authentication tokens must be securely generated and hidden to prevent tampering or leakage. The value of the token can be stored in a code area with execution-only permission (memory usage permission), such as an encryption key. In other words, a value is displayed in the immediate field of the move command, and can be loaded into a general-purpose register by executing the command as shown in FIG. 4 . Next, when the code with permission is executed, the operation is verified using the code with permission, so the value of the authentication token must be safely hidden. To this end, the authentication value is maintained in a debug register called dbgdtr_el0, and access to the token from unauthorized code is prevented through code instrumentation that prohibits the use of the register. You can protect the authentication token by keeping the authentication token value in a debug register.

Referring to Figure 4, it shows the entry gate of the sealer. The AES round key setup (lines 5 to 14) can be repeated for all 11 AES keys. Sealer uses the AES encryption algorithm with a 128-bit key length (AES 128) as an encryption algorithm, and can use 11 round keys for encryption and decryption operations respectively. The value of the AES round key is displayed in an immediate field of the move command and can be safely stored in the code like an authentication token value. AArch64's immediate register move instruction has a 16-bit immediate field, so it takes 8 move instructions to represent one round key. However, there is a problem in that all AES round keys up to 352 bytes in total cannot be loaded into system registers such as debug registers or general purpose registers due to a limited number. To solve this, the vector register can be used to efficiently load the AES round key. The vector registers supported by AArch64 are 32 registers from v0 to v31, and each register is a 128-bit register. Since the round key size of the AES 128 algorithm is also 128 bits, the round key can be loaded efficiently using vector registers v10 to v32.

5 is a diagram for describing an operation of accessing a private memory according to an exemplary embodiment.

After loading the cryptographic key and authentication token into the entry gate's registers, code that is allowed access can use these values to access the private memory. When sensitive data is stored in private memory, it must be stored in encrypted form. As shown in FIG. 5, the code that is allowed access can first encrypt sensitive data using AES 128 encryption operation and then store the sensitive data in private memory.

The code shown on lines 4 through 13 of Figure 5 represents 10 encryption rounds of AES 128 using the encryption extension of AArch64. The cryptographic extension provides four instructions (aese, aesmc, aesd and aesimc) for acceleration of the AES algorithm. Each round can encrypt the plaintext block contained in v0 using the respective AES round key (v10 to v20). Finally, the code that has been granted access can check the value of the auth token stored in the debug register to ensure that execution at this point has started in the normal flow starting at the entry gate. At this time, an attempt to directly switch an execution flow from an unauthorized code to an access-allowed code may be detected. During decryption, aesd and aesimc commands can be used with other AES round keys (v21 to v31) instead of aese and aesmc commands.

6 is an example for describing an exit gate according to an embodiment.

The sealer's exit gate shown in FIG. 6 may play a role of deleting an encryption key and an authentication token. Unlike entry gates, each AES round register loaded into a vector register can be initialized to 0 by a vector move instruction. In the case of an authentication token, it is required to check the value after initialization. By breaking the control flow, an attacker can manipulate the arbitrary value through the command on line 9.

7 is a block diagram illustrating a configuration of a data isolation system according to an embodiment, and FIG. 8 is a flowchart illustrating a data isolation method for responding to an attack inside a process according to an embodiment.

The processor of the data isolation system 100 may include a code execution unit 710 and an access control unit 720 . The components of such a processor may be representations of different functions performed by the processor according to control instructions provided by program code stored in the data isolation system. The processor and components of the processor may control the data isolation system to perform steps 810 to 820 included in the data isolation method for responding to an inside-process attack of FIG. 8 . In this case, the processor and components of the processor may be implemented to execute instructions according to the code of an operating system included in the memory and the code of at least one program.

The processor may load a program code stored in a file of a program for a data isolation method for responding to an attack inside the process into a memory. For example, when a program is executed in the data isolation system, the processor may control the data isolation system to load program code from the program's files into memory under the control of the operating system. At this time, each of the code execution unit 710 and the access control unit 720 may be different functional representations of the processor for executing subsequent steps 810 to 820 by executing instructions of corresponding portions of the program code loaded into the memory. can

In step 810, the code execution unit 710 may execute the code for which the access to which the encryption key is assigned is allowed through the memory usage authority in the architecture of the computer processor. The code execution unit 710 may classify areas accessible to important data in a thread executed in a process of the architecture of a computer processor into an entry gate and an exit gate. The code execution unit 710 may determine important data related to the code for which access is allowed, assign an encryption key to the code for which access is allowed, and encrypt the important data related to the important data through the assigned encryption key.

In step 820, the access control unit 720 may control access to sensitive data for the code for which access is allowed using the assigned encryption key while the code for which access is allowed is executed. there is. The access controller 720 reaches the entry gate of the code for which access is allowed as the thread is executed in the process of the architecture of the computer processor, and both the encryption key and the authentication token assigned to the code for which access is allowed are loaded into the entry gate. According to this code, access to important data encrypted using the assigned encryption key is accessed, and when the access is terminated, the assigned encryption key and authentication token are deleted at the exit gate, and thread execution can be maintained. . The access control unit 720 is important to the private region where each code allowed to access has the same identification information based on identification information assigned to a private region including a plurality of codes allowed for access and important data. data can be shared.

The devices described above may be implemented as hardware components, software components, and/or a combination of hardware components and software components. For example, devices and components described in the embodiments may include, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA) , a programmable logic unit (PLU), microprocessor, or any other device capable of executing and responding to instructions. A processing device may run an operating system (OS) and one or more software applications running on the operating system. A processing device may also access, store, manipulate, process, and generate data in response to execution of software. For convenience of understanding, there are cases in which one processing device is used, but those skilled in the art will understand that the processing device includes a plurality of processing elements and/or a plurality of types of processing elements. It can be seen that it can include. For example, a processing device may include a plurality of processors or a processor and a controller. Other processing configurations are also possible, such as parallel processors.

Software may include a computer program, code, instructions, or a combination of one or more of the foregoing, which configures a processing device to operate as desired or processes independently or collectively. You can command the device. Software and/or data may be any tangible machine, component, physical device, virtual equipment, computer storage medium or device, intended to be interpreted by or provide instructions or data to a processing device. can be embodied in Software may be distributed on networked computer systems and stored or executed in a distributed manner. Software and data may be stored on one or more computer readable media.

The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. Program commands recorded on the medium may be specially designed and configured for the embodiment or may be known and usable to those skilled in computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks and magnetic tapes, optical media such as CD-ROMs and DVDs, and magnetic media such as floptical disks. - includes hardware devices specially configured to store and execute program instructions, such as magneto-optical media, and ROM, RAM, flash memory, and the like. Examples of program instructions include high-level language codes that can be executed by a computer using an interpreter, as well as machine language codes such as those produced by a compiler.

As described above, although the embodiments have been described with limited examples and drawings, those skilled in the art can make various modifications and variations from the above description. For example, the described techniques may be performed in an order different from the method described, and/or components of the described system, structure, device, circuit, etc. may be combined or combined in a different form than the method described, or other components may be used. Or even if it is replaced or substituted by equivalents, appropriate results can be achieved.

Therefore, other implementations, other embodiments, and equivalents of the claims are within the scope of the following claims.

Claims (15)

In the data isolation method for responding to the attack inside the process performed by the data isolation system,
Executing a code to which access is allowed, to which an encryption key is assigned through a memory usage right, in the architecture of a computer processor; and
Controlling access to sensitive data for the code for which the access is allowed using the assigned encryption key while the code for which the access is allowed is executed.
including,
The step of executing the access-allowed code,
classifying areas accessible to the important data in a thread executed in a process of the architecture of the computer processor into entry gates and exit gates;
including,
The entry gate loads an encryption key assigned to the access-allowed code, and an authentication token is issued when the access-allowed code is entered into the entry gate;
The exit gate deletes the assigned encryption key and the issued authentication token.
A data isolation method to counter in-process attacks. According to claim 1,
The step of executing the access-allowed code,
Determining important data related to the access-allowed code, allocating an encryption key to the access-allowed code, and encrypting the important data related to the important data through the assigned encryption key.
A data isolation method to respond to attacks inside the process, including delete delete According to claim 1,
The architecture of the computer processor includes ARM's AArch64,
The memory usage right includes Execute-no-Read (XnR) introduced in AArch64, and when a command to read the assigned encryption key is executed in the code for which the access is allowed, the access is allowed for the code. A data isolation method for responding to an attack inside a process, characterized in that the assigned encryption key is protected by loading the assigned encryption key. In the data isolation method for responding to the attack inside the process performed by the data isolation system,
Executing a code to which access is allowed, to which an encryption key is assigned through a memory usage right, in the architecture of a computer processor; and
Controlling access to sensitive data for the code for which the access is allowed using the assigned encryption key while the code for which the access is allowed is executed.
including,
The control step is
As a thread executes in a process of the architecture of the computer processor, it reaches the entry gate of code that has been granted access, and as both the encryption key and authentication token assigned to the code that has been granted access are loaded into the entry gate, the access is established. Permitted code accesses sensitive data encrypted using the assigned encryption key, and when the access is terminated, deleting the assigned encryption key and authentication token from an exit gate and maintaining thread execution.
A data isolation method to respond to attacks inside the process, including According to claim 1 or 6,
The control step is
Based on identification information assigned to a private region including a plurality of codes and important data, each code to which access is permitted shares the important data in a private region having the same identification information.
A data isolation method to respond to attacks inside the process, including According to claim 1 or 6,
A data isolation method for responding to an attack inside a process, characterized in that the operation performed by the data isolation method is provided as an API. In the data isolation system,
a code execution unit that executes a code to which an encryption key is allocated through a memory usage right in the architecture of a computer processor; and
An access controller that controls access to sensitive data for the code for which access is allowed using the assigned encryption key while the code for which access is allowed is executed.
including,
The code execution unit,
Classifying areas accessible to the important data within a thread executed in a process of the architecture of the computer processor into an entry gate-exit gate,
The entry gate loads an encryption key assigned to the access-allowed code, and an authentication token is issued when the access-allowed code is entered into the entry gate;
The exit gate deletes the assigned encryption key and the issued authentication token.
Data isolation system. According to claim 9,
The code execution unit,
Determining important data related to the access-allowed code, assigning an encryption key to the access-allowed code, and encrypting the important data related to the sensitive data through the assigned encryption key
Data isolation system, characterized in that. delete delete According to claim 9,
The architecture of the computer processor includes ARM's AArch64,
The memory usage right includes Execute-no-Read (XnR) introduced in AArch64, and when a command to read the assigned encryption key is executed in the code for which the access is allowed, the access is allowed for the code. and protecting the assigned encryption key by allowing the assigned encryption key to be loaded. In the data isolation system,
a code execution unit that executes a code to which an encryption key is allocated through a memory usage right in the architecture of a computer processor; and
An access controller that controls access to sensitive data for the code for which access is allowed using the assigned encryption key while the code for which access is allowed is executed.
including,
The access control unit,
As a thread executes in a process of the architecture of the computer processor, it reaches the entry gate of code that has been granted access, and as both the encryption key and authentication token assigned to the code that has been granted access are loaded into the entry gate, the access is established. Allowed code accesses sensitive data encrypted using the assigned encryption key, and when the access is terminated, deletes the assigned encryption key and authentication token from the exit gate and maintains thread execution.
Data isolation system, characterized in that. The method of claim 9 or 14,
The access control unit,
Based on the identification information assigned to a private region containing a plurality of codes and important data, each of the codes to which access is permitted shares the important data in a private region having the same identification information.
Data isolation system, characterized in that.

Images