WO2022011818A1

WO2022011818A1 - Kernel sensitive data integrity protection method based on arm pointer authentication

Info

Publication number: WO2022011818A1
Application number: PCT/CN2020/114971
Authority: WO
Inventors: 申文博; 杨昱天; 周亚金; 任奎
Original assignee: 浙江大学
Priority date: 2020-07-14
Filing date: 2020-09-14
Publication date: 2022-01-20
Also published as: CN111881485B; CN111881485A

Abstract

A kernel sensitive data integrity protection method based on ARM pointer authentication, to provide integrity protection for sensitive data specified by a user in an operating system kernel by using a universal pointer authentication code. The method comprises the following steps: (1) positioning all reading and writing for sensitive data in an operating system kernel code by means of a points-to analysis technology; (2) inserting a pointer authentication instruction such that a pointer authentication code is generated and written before writing the sensitive data to a memory, and the pointer authentication code is checked after reading the sensitive data from the memory; and (3) modifying a kernel start code of an operating system, initializing pointer authentication characteristics at the early stage of start, and then initializing the pointer authentication code of global sensitive data. This method efficiently protects the integrity of the sensitive data of the operating system kernel by using a pointer authentication technology.

Description

A Kernel Sensitive Data Integrity Protection Method Based on ARM Pointer Verification

technical field

The invention relates to the field of computer system security, in particular to a protection method for the integrity of kernel sensitive data based on ARM pointer authentication (Pointer Authentication, PA).

Background technique

The operating system is the basis for the operation of the computer system, and any security problems on it will directly endanger the overall security of the system. Attacks targeting operating systems have emerged in recent years, such as Stuxnet in 2010 and the WannaCry worm ransomware from 2017 to 2019. According to the evolution of attack methods, attacks on operating systems are mainly divided into three categories: code injection attacks, code reuse attacks, and uncontrolled data attacks. At the same time, operating system security has been greatly improved in the continuous confrontation between attackers and defenders. With the large-scale deployment of anti-code injection attack hardware security features, mainstream operating systems have implemented hardware-based anti-code injection attack protection. . Due to its ubiquity, code reuse attacks have been widely studied by industry and academia, and some mature protection methods such as Control-Flow Integrity (CFI) have been deployed on practical software. , the effective attack surface of code reuse attacks is shrinking.

Compared with the first two types of attacks, non-controlled data attacks can directly tamper with sensitive data in the system and provide attackers with illegal rights; however, the means of tampering with sensitive data are concealed and difficult to detect and monitor, posing a major threat to operating system security. . Due to the lack of dedicated hardware support, the current software-based sensitive data protection introduces excessive performance overhead, hindering its large-scale deployment.

SUMMARY OF THE INVENTION

The purpose of the embodiments of the present invention is to provide a kernel sensitive data integrity protection method based on ARM pointer verification, so as to solve the problem of excessive performance overhead introduced by software-based sensitive data protection.

In order to achieve the above purpose, the technical solutions adopted in the embodiments of the present invention are as follows:

The embodiment of the present invention provides a kernel sensitive data integrity protection method based on ARM pointer verification, including:

Receive sensitive data specified by the user in the operating system kernel code;

Perform pointing analysis on user-specified sensitive data to identify all sensitive pointers that may point to sensitive data;

According to the identified sensitive pointers, combined with the semantics of the operating system kernel code, identify all operations of reading and writing memory through sensitive pointers, among which the operation of writing memory through sensitive pointers is referred to as sensitive writing, and the operation of reading memory through sensitive pointers is referred to as sensitive reading;

According to the identified sensitive read and write operations, modify the operating system kernel code as follows: insert the sensitive data PAC generation code StoreSign _key _{(sensdata) after the sensitive write code, insert the sensitive data PAC verification code LoadAuth key} after the sensitive read code (sensdata), where key represents the 128-bit PA key, and sensdata represents sensitive data. When the operating system kernel is running, the inserted PAC generation code is dynamically executed to generate the PAC of the sensitive data, and the inserted PAC verification code is dynamically executed to verify the PAC of the sensitive data. , if the PAC verification is passed, the sensitive data is complete; otherwise, the integrity of the sensitive data is destroyed;

Insert the PA key initialization code keyinit() into the operating system kernel startup code, the PA key initialization code enables the PA feature of the ARM CPU and initializes the PA key with a random number;

According to the sensitive data specified by the user in the operating system kernel code, analyze the global variables in the operating system kernel code, and determine all the global variables in the operating system kernel that contain sensitive data;

According to the determined global variables containing sensitive data, insert the global sensitive data initialization code sensvar_init() after keyinit(), the global sensitive data initialization code calls the StoreSign _key (gsensdata) for all global sensitive data variables, where gsensdata represents global sensitive data .

Further, receive sensitive data specified by the user in the operating system kernel code, including:

Receive the attribute declaration __attribute__ provided by the compiler to specify the sensitive data in the operating system kernel, where the sensitive data is a single byte or a data block composed of multiple bytes.

Further, point-to-point analysis is performed on user-specified sensitive data, including:

In the LTO stage of the operating system kernel code compilation, the CLA algorithm is used to analyze the sensitive data specified by the user based on the LLVM intermediate representation code of the entire kernel.

Further, combined with the semantics of the operating system kernel code, identify all operations that read and write memory through sensitive pointers, including:

(4-1) In the LTO stage of the operating system kernel code compilation, scan each instruction in the LLVM intermediate representation code of the entire kernel one by one;

(4-2) If the current instruction is a LOAD instruction or a memory block copy function, and its source operand is a sensitive pointer, mark the current instruction as a sensitive read instruction;

(4-3) If the current instruction is a STORE instruction or a memory block copy function, and its source operand is a sensitive pointer, the current instruction is marked as a sensitive write instruction.

Further, the steps of inserting the sensitive data PAC generating code StoreSign _key (sensdata) after the sensitive writing code includes:

(5-1) Divide sensitive data into data blocks D ₀ , D ₁ , . . . , D _{n-1 in} units of 8 bytes, where n is the number of data blocks;

(5-2) to a first data block D ₀ as an input to the memory address ADDR _₀ D ₀ where as modifiers, calculated with key KEY PA _{_{_{PAC 0 = Sign key (D 0}}} , ADDR 0);

(5-3) Take each data block as input in turn, and the PAC of the previous iteration result as a modifier, iteratively calculate PAC _i =Sign _key (D _i , PAC _i-1 ) (0<i<n);

(5-4) Take PAC _n-1 as the PAC of sensitive data, and store the sensitive data in a position adjacent to the high address of the sensitive data.

Further, the step of inserting the PAC verification code LoadAuth _key (sensdata) of the sensitive data after the sensitive reading code includes:

(6-1) Divide sensitive data into data blocks D ₀ , D ₁ , . . . , D _{n-1 in} units of 8 bytes, where n is the number of data blocks;

(6-2) to a first data block D ₀ as an input to the memory address ADDR _₀ D ₀ where as modifiers, calculated with key KEY PA _{_{_{PAC 0 = Sign key (D 0}}} , ADDR 0);

(6-3) Take each data block as input in turn, and the PAC of the previous iteration result as a modifier, iteratively calculate PAC _i =Sign _key (D _i , PAC _i-1 ) (0<i<n);

(6-4) Take out the PAC stored in the adjacent position of the high address of the sensitive data and compare it with PAC _n-1 . If it is consistent, the sensitive data is complete and the verification is passed; if it is inconsistent, the integrity of the sensitive data is destroyed and the verification fails;

(6-5) If the verification is passed, the operating system kernel can run normally; if the verification fails, the execution of the operating system is stopped, and an alarm is notified of the abnormality of the operating system kernel.

According to the above technical solutions, the beneficial effect of the present invention is that the present invention uses the pointing analysis technology to identify all sensitive pointers, which saves time and effort compared to manual analysis and can cover all sensitive pointers; Inserting PAC generation and PAC verification codes can protect the integrity of all sensitive data; the invention realizes protection based on the PA hardware characteristics of ARM, and greatly reduces performance overhead compared with software implementation.

Description of drawings

The accompanying drawings described herein are used to provide a further understanding of the present invention and constitute a part of the present invention. The exemplary embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute an improper limitation of the present invention. In the attached image:

1 is a flowchart of a method for protecting the integrity of kernel sensitive data based on ARM pointer verification provided by an embodiment of the present invention;

Figure 2 is a block chain pointer verification code generation algorithm for generating pointer verification codes for kernel sensitive data blocks.

detailed description

In order to make the purpose, technical solutions and advantages of the present application clearer, the technical solutions of the present application will be described clearly and completely below in conjunction with the specific embodiments of the present application and the corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of the present application, but not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present application.

1 is a flowchart of a method for protecting the integrity of kernel sensitive data based on ARM pointer verification provided by an embodiment of the present invention; a method for protecting the integrity of kernel sensitive data based on ARM pointer verification provided in this embodiment, the present embodiment Taking the protection of sensitive data of the Linux operating system kernel as an example, the method includes the following steps:

Step S101, receiving sensitive data specified by the user in the operating system kernel code;

Specifically, this embodiment modifies the front end of the LLVM compiler to support the new attribute declaration __attribute__((sensitive)); the user declares sensitive data through the new attribute declaration __attribute__((sensitive)), where the sensitive data is controlled by the kernel The developer specifies that it can be data of any size at any location in memory, either a single byte or a data block composed of multiple bytes.

Step S102, point and analyze the sensitive data specified by the user, and identify all sensitive pointers that may point to the sensitive data;

Specifically, this example uses the LTO compilation mode of LLVM to compile the intermediate representation (Intermediate Representation, IR) bytecode of the entire operating system kernel; the CLA algorithm (Heintze, N., & Tardieu, O) is used on the intermediate representation bytecode. .(2001).Ultra-fast aliasing analysis using CLA:A million lines of C code in a second.ACM SIGPLAN Notices, 36(5), 254-263.) Point analysis to the sensitive data declared in step S101, identify to all sensitive pointers that might point to sensitive data.

Step S103 , according to the identified sensitive pointer and in combination with the semantics of the operating system kernel code, identify all operations of reading and writing memory through the sensitive pointer, wherein the operation of writing memory through the sensitive pointer is referred to as sensitive writing, and the operation of reading memory through the sensitive pointer is referred to as sensitive writing. read; specifically, including the following sub-steps:

(4-1) according to the IR bytecode of the entire operating system kernel obtained in step S102, scan each instruction in the LLVM intermediate representation code of the entire kernel one by one;

Step S104, according to the identified sensitive read and write operations, modify the operating system kernel code as follows: insert the PAC generation code StoreSign _key (sensdata) of the sensitive data after the sensitive writing code, insert the PAC verification of the sensitive data after the sensitive reading code Code LoadAuth _key (sensdata), where key represents a 128-bit PA key, and sensdata represents sensitive data. Figure 2 illustrates the _{block chain PAC generation algorithm used in StoreSign key} (sensdata) and LoadAuth _key (sensdata), corresponding to sub-steps (5-1), (5-2), (5-3), (6-1) ), (6-2) and (6-3).

_{Among them, the step of generating the code StoreSign key} (sensdata) from the PAC of the sensitive data includes the following sub-steps:

_{Among them, the step of LoadAuth key} (sensdata) of the PAC verification code for sensitive data includes the following sub-steps:

Step S105, insert PA key initialization code keyinit() in operating system kernel startup code, this PA key initialization code opens the PA characteristic of ARM CPU and initializes PA key with random number;

Specifically, the PA key initialization code keyinit() is inserted after the boot_init_stack_canary() statement in start_kernel(). keyinit() should be located after the random number generator initialization function of the Linux operating system, because keyinit() needs to call the random number generator.

Step S106, according to the sensitive data specified by the user in the operating system kernel code, analyze the global variables in the operating system kernel code, and determine all the global variables in the operating system kernel that contain sensitive data;

Specifically, according to the IR bytecode of the entire Linux operating system kernel obtained in step S102, the global variables declared in the bytecode are enumerated and the global variables containing sensitive data are recorded.

Step S107, according to the determined global variable containing sensitive data, insert the global sensitive data initialization code sensvar_init() after keyinit(), the global sensitive data initialization code calls the StoreSign _key (gsensdata) on all global sensitive data variables, where gsensdata represents Globally sensitive data.

Specifically, this step initializes the PAC for global sensitive data. The global sensitive data has integrity by default during initialization. The present invention directly generates the PAC corresponding to the global sensitive data when the operating system kernel starts, so that the global sensitive data can pass the LoadAuth _key (sensdata) when it is read by the operating system kernel for the first time. Integrity verification.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included in the scope of the present invention. within the scope of protection.

Claims

A kind of kernel sensitive data integrity protection method based on ARM pointer verification, is characterized in that, comprises:

Receive sensitive data specified by the user in the operating system kernel code;

Perform pointing analysis on user-specified sensitive data to identify all sensitive pointers that may point to sensitive data;

According to the identified sensitive pointers, combined with the semantics of the operating system kernel code, identify all operations of reading and writing memory through sensitive pointers, among which the operation of writing memory through sensitive pointers is referred to as sensitive writing, and the operation of reading memory through sensitive pointers is referred to as sensitive reading;

According to the identified sensitive read and write operations, modify the operating system kernel code as follows: insert the sensitive data PAC generation code StoreSign key (sensdata) after the sensitive write code, insert the sensitive data PAC verification code LoadAuth key after the sensitive read code (sensdata), where key represents the 128-bit PA key, and sensdata represents sensitive data. When the operating system kernel is running, the inserted PAC generation code is dynamically executed to generate the PAC of the sensitive data, and the inserted PAC verification code is dynamically executed to verify the PAC of the sensitive data. , if the PAC verification is passed, the sensitive data is complete; otherwise, the integrity of the sensitive data is destroyed;

Insert the PA key initialization code keyinit() into the operating system kernel startup code, the PA key initialization code enables the PA feature of the ARM CPU and initializes the PA key with a random number;

According to the sensitive data specified by the user in the operating system kernel code, analyze the global variables in the operating system kernel code, and determine all the global variables in the operating system kernel that contain sensitive data;

According to the determined global variables containing sensitive data, insert the global sensitive data initialization code sensvar_init() after keyinit(), the global sensitive data initialization code calls the StoreSign key (gsensdata) for all global sensitive data variables, where gsensdata represents global sensitive data .
A kind of kernel sensitive data integrity protection method based on ARM pointer verification according to claim 1, is characterized in that, receiving the sensitive data specified by the user in the operating system kernel code, comprising:

Receive the attribute declaration __attribute__ provided by the compiler to specify the sensitive data in the operating system kernel, where the sensitive data is a single byte or a data block composed of multiple bytes.
A kind of kernel sensitive data integrity protection method based on ARM pointer verification according to claim 1, is characterized in that, the sensitive data specified by the user is pointed to and analyzed, comprising:

In the LTO stage of the operating system kernel code compilation, the CLA algorithm is used to analyze the sensitive data specified by the user based on the LLVM intermediate representation code of the entire kernel.
A kind of kernel sensitive data integrity protection method based on ARM pointer verification according to claim 1, it is characterized in that, combined with the semantics of operating system kernel code, identify all operations of reading and writing memory by sensitive pointer, including:

(4-1) In the LTO stage of the operating system kernel code compilation, scan each instruction in the LLVM intermediate representation code of the entire kernel one by one;

(4-2) If the current instruction is a LOAD instruction or a memory block copy function, and its source operand is a sensitive pointer, mark the current instruction as a sensitive read instruction;

(4-3) If the current instruction is a STORE instruction or a memory block copy function, and its source operand is a sensitive pointer, the current instruction is marked as a sensitive write instruction.
A kind of kernel sensitive data integrity protection method based on ARM pointer verification according to claim 1, is characterized in that, the step of inserting the PAC generation code StoreSign key (sensdata) of sensitive data after the sensitive writing code, comprising:

(5-1) Divide sensitive data into data blocks D 0 , D 1 , . . . , D n-1 in units of 8 bytes, where n is the number of data blocks;

(5-2) to a first data block D 0 as an input to the memory address ADDR 0 D 0 where as modifiers, calculated with key KEY PA PAC 0 = Sign key (D 0 , ADDR 0);

(5-3) Take each data block as input in turn, and the PAC of the previous iteration result as a modifier, iteratively calculate PAC i =Sign key (D i , PAC i-1 ) (0<i<n);

(5-4) Take PAC n-1 as the PAC of sensitive data, and store the sensitive data in a position adjacent to the high address of the sensitive data.
A kind of kernel sensitive data integrity protection method based on ARM pointer verification according to claim 1, is characterized in that, the step of inserting the PAC verification code LoadAuth key (sensdata) of sensitive data after the sensitive reading code, comprising:

(6-1) Divide sensitive data into data blocks D 0 , D 1 , . . . , D n-1 in units of 8 bytes, where n is the number of data blocks;

(6-2) to a first data block D 0 as an input to the memory address ADDR 0 D 0 where as modifiers, calculated with key KEY PA PAC 0 = Sign key (D 0 , ADDR 0);

(6-3) Take each data block as input in turn, and the PAC of the previous iteration result as a modifier, iteratively calculate PAC i =Sign key (D i , PAC i-1 ) (0<i<n);

(6-4) Take out the PAC stored in the adjacent position of the high address of the sensitive data and compare it with PAC n-1 . If it is consistent, the sensitive data is complete and the verification is passed; if it is inconsistent, the integrity of the sensitive data is destroyed and the verification fails;

(6-5) If the verification is passed, the operating system kernel can run normally; if the verification fails, the execution of the operating system is stopped, and an alarm is notified of the abnormality of the operating system kernel.