CN114115836B

CN114115836B - Design method and system of trusted TCM software stack based on Linux operating system

Info

Publication number: CN114115836B
Application number: CN202210103672.XA
Authority: CN
Inventors: 屈志林; 王文功; 张志成; 杨诏钧; 魏立峰; 姬一文
Original assignee: Kirin Software Co Ltd
Current assignee: Kirin Software Co Ltd
Priority date: 2022-01-28
Filing date: 2022-01-28
Publication date: 2022-05-10
Anticipated expiration: 2042-01-28
Also published as: CN114115836A

Abstract

The application discloses a method and a system for designing a trusted TCM software stack based on a Linux operating system, which can realize the communication interaction between upper-layer application and a trusted TCM chip in a domestic Linux operating system, realize trusted calculation, ensure the integrity and authenticity of data, resist tampering attack, safely execute codes, protect the confidentiality of sensitive data and the like. Resource management of the trusted TCM chip is added in a Tcs layer of a Trouiser software stack, so that the bottleneck of limited resources of the trusted TCM chip is better solved, and the utilization rate of the trusted TCM chip resources by a user is improved.

Description

Design method and system of trusted TCM software stack based on Linux operating system

Technical Field

The application relates to the field of trusted TCM software stacks, in particular to a method and a system for designing a trusted TCM software stack based on a Linux operating system.

Background

With the continuous development of computer applications, the problem of security threat becomes more and more serious, and the traditional method of simply relying on software to resist the security threat often cannot solve the problem. The main technologies of traditional information security are firewalls, intrusion detection and antivirus software. When the firewall is built more and more, the intrusion detection is more and more complex, and the virus library is also more and more huge, the whole information security situation still has a trend of becoming complex and chaotic: the false alarm rate is increased, the security investment is continuously increased, the maintenance and management are more complex and difficult to implement, the use efficiency of the information system is greatly reduced, and the defense capability to new attack intrusion is absent. The traditional information security system mainly composed of the old three samples (firewall, intrusion detection and virus prevention) takes the prevention as the key point, only passively resists attacks outside the system, and cannot fundamentally solve the security problem of the system. The simple passive defense is not an effective solution to the security problem of the computer system, and related researchers are prompted to actively take comprehensive measures from the aspect of terminals to deal with the problem, so that the trusted computing theory comes up. Trusted computing relies on a Trusted Platform Module (TPM), which is a Trusted root of a Trusted computing Platform, establishes a chain of trust from hardware to firmware and then to an operating system until the integrity of an application program, provides hardware support for the secure storage and authentication functions of the system, and improves the security of the whole computing system by ensuring the security of each computer terminal.

The TPM is essentially a storage device embedded on the motherboard, which operates passively, and when the computer system boots, the TPM starts operating immediately after the BIOS boots, measures the platform information and then boots the operating system until the system boots securely. To build Trusted Computing platforms with TPM as the core, the international Trusted Computing Group (TCG) introduced a series of industrial specifications based on TPM. Generally, a TCG Device Driver Library (TDDL) is used to communicate with a TPM, and in general, the TDDL first performs session communication with a TPM Device Driver in a kernel and then interacts with a real TPM Device through the Device Driver.

The prism door event rings the message-safe alarm again. We want to build an autonomous trusted computing cryptography support platform rather than directly adopt the TCG organization's technology and specifications. In a trusted computing system, a cryptographic technology is used as a center, if commercial passwords do not have own intellectual property right, most products used by users adopt foreign technologies and solutions, for example, a large amount of TPM modules applying foreign cryptographic algorithms are used, and the information security leading right of the country is difficult to guarantee. A Trusted Cryptography Module (TCM) references the concept and technology of the TPM, but adopts a self-owned cryptographic algorithm of China, adds a symmetric cryptographic algorithm, adopts different certificate management systems and simplifies an authorization protocol. The user works the TCM chip to perform system measurement before formally starting the meter OS, so that the integrity of data is not damaged.

At present, a trusted computing cryptography support platform independently developed in china is mainly composed of a trusted cryptography Module TCM and a TCM Service Module (TSM), and functional architectures of the trusted computing cryptography support platform correspond to the TPM and the TSS of the trusted platform Module in the TCG organization respectively. Therefore, it is an important and meaningful matter to implement the TSM based on the chinese domestic operating system and the TCM hardware platform. In order to use the trusted cryptography module TCM, the user needs a software module, which is a trusted software stack, to interact with. The trusted software stack is used as an inlet for using the trusted cryptography module TCM, is positioned between the user application software and the TCM, mainly provides functions of access, security authentication, cryptography service, resource management and the like of the TCM security chip, and solves the problems of complexity of an interface of the trusted TCM chip and inconvenience of external service. The existing trusted software stack is generally used directly by the open source software stack or slightly modified. The trusted TCM chip has small resource space, brings great limitation to application layer use, needs to improve the access utilization of an upper software stack interface to trusted TCM chip resources, and cannot be well adapted to the independently developed trusted computing trusted TCM chip. Some interfaces (such as creating a key interface) have complicated parameters, so that it is difficult for a general user to fill in the parameters correctly, and the requirements of the interfaces for the parameters are very strict, so that errors can be caused if the parameters slightly do not meet the requirements, and calling errors can be caused. In summary, the existing trusted software stack has a low access utilization rate to the trusted TCM chip resources, and the interface parameters are complex and prone to error.

Disclosure of Invention

The invention mainly aims to provide a method and a system for designing a trusted TCM software stack based on a Linux operating system, and solves the problem that the trusted TCM chip resource access utilization rate is low by the trusted software stack.

In order to achieve the above object, a first aspect of the present invention provides a method for designing a trusted TCM software stack based on a Linux operating system, where the trusted TCM software stack includes a Feature API interface layer and a trouser-TCM software stack, and includes the following steps:

adding a resource management module in the Troursers-TCM software stack, wherein the resource management module is used for detecting and scheduling trusted TCM chip resources by adopting a least recently used algorithm when a master key is created, and comprises the following steps:

judging whether the trusted TCM chip resources are full, if so, selecting a key with the minimum LRU value in the loaded keys, calling a ContextSave interface to store the key data to a TCMS _ CONTEXT structure body, calling a ContextFlush interface to clear the key data, then updating the LRU and STATUS, packaging a command data packet for creating a main key, finishing data interaction with the trusted TCM chip, then analyzing data returned by the trusted TCM chip, acquiring a key handle, converting the key handle into a virtual handle, and storing the key handle and the virtual handle into a linked list;

and if the chip resources are not full, directly packaging the command data packet for creating the master key and performing subsequent steps.

Optionally, the resource management module is further configured to detect and schedule the trusted TCM chip resource by using a least recently used algorithm when the subkey is loaded, where the method includes:

step S1: detecting whether a master key for generating the subkey is loaded, if not, executing step S2, and if so, executing step S3;

step S2: judging whether the trusted TCM chip resources are full, if so, selecting a key with the minimum LRU value in the loaded keys, storing the key data by using a ContextSave interface, removing the key data by calling a ContextFlush interface, calling a Contextload interface to reacquire the main key stored in the TCMS _ CONTEXT structure, and then entering step S3;

step S3: judging whether the trusted TCM chip resources are full, if so, selecting a key with the minimum LRU value in the loaded keys, calling a ContextSave interface to store the key data in a TCMS _ CONTEXT structure, calling a ContextFlush interface to clear the key data, then updating LRU and STATUS, packaging a command data packet for creating the sub-keys, finishing data interaction with the trusted TCM chip, analyzing data returned by the trusted TCM chip, acquiring a key handle, converting the key handle into a virtual handle, storing the key handle and the virtual handle into a linked list, and if not, directly packaging the command data packet for creating the sub-keys and performing subsequent steps.

Optionally, the trouser-TCM software stack includes a System API interface after migration and optimization.

Optionally, the step of migrating a System API interface to the trouser-TCM software stack is: and modifying a source code in the Troursers-TCM software stack by using the System API interface to realize a corresponding function again, wherein the source code comprises a parameter format, a data command protocol, a parameter packaging and analyzing code, and the corresponding function comprises key creation and key handle acquisition.

Optionally, the step of optimizing the System API interface includes:

and encapsulating the System API interface parameters.

Optionally, the encapsulating System API interface parameters includes:

and packaging the System API interface parameters by using an XML file to form an XML module, and simplifying the System API interface parameters by the XML module.

The invention provides a trusted TCM software stack System based on a Linux operating System, which comprises a Feature API (application programming interface) layer and a Troousers-TCM software stack, wherein the Troousers-TCM software stack comprises a System API layer, a resource management module and a Tddl layer which are arranged from top to bottom, and the System API layer comprises a Tspi layer, a Tcsd layer and a Tcs layer which are arranged from top to bottom; wherein the content of the first and second substances,

the Feature API interface layer is used for encapsulating input parameters and simplifying a parameter structure;

the Tspi layer is used for converting character strings of the parameters and sending the character strings to the Tcsd layer in a data packet mode;

the Tcsd layer is used for completing initialization work, receiving a data packet sent by the Tspi layer and sending the data packet to the Tcs layer;

the Tcs layer is used for receiving and analyzing a data packet sent by the Tcsd layer, acquiring parameter information, and then carrying out command format encapsulation on the parameter information through a bottom layer interface;

the resource management module is used for dynamically detecting and scheduling trusted TCM chip resources by adopting a least recently used algorithm;

and the Tddl layer is used for completing data transmission through the equipment file and the trusted TCM chip.

According to the technical scheme, the embodiment of the application has the following advantages:

the design method and the system of the trusted TCM software stack based on the Linux operating system can realize the communication interaction between upper-layer application and the trusted TCM chip in the domestic Linux operating system, realize trusted calculation, ensure the integrity and authenticity of data, resist tampering attack, safely execute codes, protect the confidentiality of sensitive data and the like. Resource management of the trusted TCM chip is added on a Tcs layer of a Troousers software stack, so that the bottleneck of limited resources of the trusted TCM chip is better solved, and the utilization rate of the trusted TCM chip resources by a user is improved.

In addition, the XML file is used for packaging the hierarchical object structure body of the interface to form a template file, the XML file can be directly and conveniently assigned with value by being directly modified, errors are not easy to occur, and interface parameters are simplified and improved.

Drawings

In order to express the technical scheme of the embodiment of the invention more clearly, the drawings used for describing the embodiment will be briefly introduced below, and obviously, the drawings in the following description are only some embodiments of the invention, and other drawings can be obtained by those skilled in the art without creative efforts.

FIG. 1 is a functional framework diagram of a trusted computing password support platform;

FIG. 2 is a block diagram of trusted TCM chip functional modules;

FIG. 3 is an architectural diagram of a TSM;

FIG. 4 is a flowchart of steps of a method for designing a trusted TCM software stack according to an embodiment of the present application;

FIG. 5 is a block diagram of a trusted TCM software stack system in an embodiment of the present application;

FIG. 6 is a data processing flow diagram of a trusted TCM software stack system in an embodiment of the present application;

FIG. 7 is a flow chart of creating a master key in an embodiment of the present application;

fig. 8 is a flowchart of loading a subkey in the embodiment of the present application.

Detailed Description

In order to make the technical solutions of the present application better understood, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

In order to enable those skilled in the art to better understand the scheme of the present application, it is necessary to understand the current situation of the existing domestic trusted computing password support platform. The purpose of the application is to adapt an independently developed trusted computing trusted TCM chip on a domestic operating system, and upper-layer application is convenient to communicate and interact with the trusted TCM chip to perform trusted computing. The trusted computing password support platform developed by China mainly comprises a trusted password module (TCM) and a TCM Service Module (TSM). Referring to fig. 1, the trusted computing password support platform uses a trusted password module as a root of trust, and implements a platform security function through the following three mechanisms and a platform security management function.

(1) And calculating the integrity metric value of the system platform by taking the credibility metric root as a starting point, establishing a trust chain of the system platform of the computer, and ensuring the credibility of the system platform.

(2) The credible report root marks the credibility of the platform identity, has uniqueness, and realizes platform identity certification and integrity report on the basis of the credible report root.

(3) Based on the trusted storage root, the key management and platform data security protection functions are realized, and corresponding password service is provided.

A Trusted Cryptography Module (TCM) is a security subsystem embedded in a computer and is also a necessary key component of a trusted computing cryptography support platform, and the core function of the TCM is mainly to provide hardware-level domestic cryptographic algorithm and key protection; uniquely identifying a platform identity; and the integrity of the platform is measured, and the immunity of the platform is improved. Independent cryptographic algorithm support. The TCM is a set of hardware and firmware, and can be in an independent packaging form, or integrated with other types of chips in an IP core manner to provide TCM functions. The basic structure of the device is shown in FIG. 2. The various modules and functions of the TCM are as follows:

(1) an I/O control section: input and output hardware interfaces of the TCM. The I/O is responsible for the communication of all algorithm engines, storage areas and registers with other interfaces and application programs;

(2) SM4 engine: executing an SM4 symmetric cryptographic operation unit;

(3) SM2 engine: a unit for generating SM2 key pair and performing SM2 encryption/decryption and signature operation;

(4) SM3 engine: a unit for performing a hash operation;

(5) a random number generator: a random number generating unit;

(6) HMAC engine: a computing message authentication unit based on the SM3 engine;

(7) an execution engine: an arithmetic execution unit of the TCM;

(8) non-volatile memory: a storage unit storing permanent data;

(9) a volatile memory: and the memory unit of temporary data when the TCM is in operation.

The trusted cryptographic service module TSM is a main entry for a trusted application to access the TCM, as a software core of a trusted computing platform. Viewed from the whole, the structure is a stack structure and consists of a plurality of discrete layers, and clear access interfaces are arranged among the layers. Although the module and component features of the TSM vary from platform to platform, the interaction relationship between the modules is the same, so the TSM architecture is not platform dependent. Architectural diagram of a TSM see fig. 3. The TSM is composed of three software modules, namely TCM Service Provider (TSP), TCM Core Service (TCS), and TCM Device Driver Library (TDDL). The TDDL and TCS exist in system services, and the TSP exists in a user program. In addition, a TCM Device Driver (TDD) associated with the TSM exists at the kernel level.

TCM Service Provider (TSP)

The TSP provides TCM service to the application program, so that the application program only pays attention to the characteristics of the application program, and the TSP executes the trusted function provided by TCM by providing a TCM function interface of an upper layer. The TSP also provides auxiliary functions that facilitate functional operations that are not provided by the TCM, such as: signature verification function. TSPs are located in application processes, making each application appear to have its own TSP.

TCM Core Service (TCS)

The TCS is positioned between a TSM Service Provider (TSP) layer and a TCM Device Driver Library (TDDL) layer, exists in the form of system service, and provides functional interfaces such as TCM use, key management and the like for upper-layer applications such as the TSP and the like.

TCM equipment driver library (TDDL)

The TDDL is positioned in front of a TCM Core Service (TCS) layer and a TCM Device Driver (TDD) layer, and the main purpose is to provide a standard interface above TDD, shield the difference of device I/O control information and complete the information transmission between user software and a kernel.

The advantages of the TDDL design are:

ensuring that any TCM can interact with the TSM realized by different methods;

the TCM application is provided with an operating system independent interface.

TCM Device Driver (TDD)

TDD is a module in kernel mode, provided by TCM manufacturers, and embedded with code that can understand the specific behavior of TCM. Because user mode execution does not have access to kernel mode execution, the manufacturer also provides a library of TCM device drivers that are opened by the TSM, which do not allow any programs to connect to the TCM device except for the TSM.

In order to ensure that the industrial control system and application can conveniently call the resources of the trusted TCM chip, the invention utilizes the framework of the existing troussrs software stack for development, wherein a Least Recently Used (LRU) algorithm is adopted in a trusted TCM chip resource management module to schedule the trusted TCM chip resources, and the access utilization rate of an upper-layer interface to the trusted TCM chip resources is improved.

The embodiment of the application provides a design method of a trusted TCM software stack based on a Linux operating system, wherein the trusted TCM software stack comprises a Feature API interface layer and a Troousers-TCM software stack, and referring to FIG. 4, the design method comprises the following steps: and adding a resource management module in the Troousers-TCM software stack, wherein the resource management module detects and schedules the trusted TCM chip resources by adopting a least recently used algorithm.

The trusted TCM chip resource management module can dynamically detect the resource allocation condition of the current trusted TCM chip and allocate the current resources, and the user layer does not need to manually allocate the internal resources of the trusted TCM chip. When the resource interface is called, the current trusted TCM chip resource is reconfigured through the resource management module, and the interface is ensured to have enough resource space for use every time. The handles acquired by the application layer are all virtual handles which can be directly used, after the virtual handles are transmitted to the resource management module, the virtual handles are automatically replaced into key handles and then the relevant operation of the interface is carried out, and the replacement mode adopts a Least Recently Used (LRU) algorithm for automatic allocation. When the chip resource space is detected to be insufficient, the least recently used key is found out from the loaded keys by using a least recently used algorithm, the key data is saved by calling a ContextSave interface, the key data is cleared by calling a ContextFlush interface, so that the key data does not occupy the chip resource space, but the key data is not lost and is only saved in the TCMS _ CONTEXT structure body, and if the key needs to be used again, the key can be reloaded into the chip from the TCMS _ CONTEXT structure body by calling a ContextLoad interface.

There are many scenarios for resource allocation of the trusted TCM chip, where creating a master key and loading a sub-key are common working scenarios of the trusted TCM chip, and the following specifically describes the process of creating the master key and loading the sub-key as an example. The master key is a parent key and is a root key for generating the child key through encryption, and the child key is generated through decryption of the master key, so that the safety of the child key is improved. Initialization generates the master key whenever encryption, decryption, signing, etc. are used. Application scenarios: you will not give you the master key if you generate a key that is to be given to someone else. And generating corresponding sub-keys according to the main key, so that the safety of key management of the user is ensured, and meanwhile, the key for other people cannot be cracked by the outside, and only the sub-keys can be decrypted by the main key in the hand of the user.

Referring to fig. 7, when creating the master key, the detecting and scheduling trusted TCM chip resources using the least recently used algorithm includes: judging whether the trusted TCM chip resources are full, if so, selecting a key with the minimum LRU value in the loaded keys, calling a Contextsave interface to store the key data into a TCMS _ CONTEXT structure body, calling a ContextFLUsh interface to clear the key data, then updating the LRU and STATUS, packaging a command data packet for creating a main key, finishing data interaction with the trusted TCM chip, then analyzing data returned by the trusted TCM chip, acquiring a key handle, converting the key handle into a virtual handle, and storing the key handle (namely the real handle in FIG. 7) and the virtual handle into a linked list; and if the chip resources are not full, directly packaging the command data packet for creating the master key and performing subsequent steps. The ContextSave and ContextFlush interfaces are names of function functions realized by using C language, key data are operated by calling the interfaces, the ContextSave function is used for storing the key data, and the ContextFlush function is used for clearing the key data; TCMS _ CONTEXT is the name of a data structure of key data encapsulated in C language, and LRU and STATUS are two data variables in the data structure, STATUS indicates the loading state (loading or unloading) of the current key, and LRU indicates the most recent usage of the key.

Referring to fig. 8, when loading the subkey, the detecting and scheduling the trusted TCM chip resources by using the least recently used algorithm includes:

step S1: detecting whether a master key for generating a subkey is loaded, if not, executing step S2, and if so, executing step S3;

step S3: judging whether the trusted TCM chip resources are full, if so, selecting a key with the minimum LRU value in the loaded keys, calling a ContextSave interface to store the key data in a TCMS _ CONTEXT structure, calling a ContextFlush interface to clear the key data, then updating LRU and STATUS, encapsulating a command data packet for creating the sub-keys, finishing data interaction with the trusted TCM chip, analyzing data returned by the trusted TCM chip, acquiring a key handle, converting the key handle into a virtual handle, storing the key handle (namely the real handle in the figure 8) and the virtual handle into a linked list, and if not, directly encapsulating the command data packet for creating the sub-keys and performing subsequent steps.

The method can realize the communication interaction between the upper-layer application and the trusted TCM chip in the domestic operating system, realize the trusted calculation, ensure the integrity and authenticity of data, resist tampering attack, safely execute codes, protect the confidentiality of sensitive data and the like. Resource management of the trusted TCM chip is added on a Tcs layer of a Troousers software stack, so that the bottleneck of limited resources of the trusted TCM chip is better solved, and the utilization rate of the trusted TCM chip resources by a user is improved.

In an improved embodiment, the trusted TCM software stack based on the Linux operating System comprises a System API interface after transplantation and optimization.

The System API is a System level API, is a relatively low-level function realized by C language, is similar to a C language library function, supports an ANSI C compiler and is convenient for cross-platform transplantation. The System API interface may encapsulate input data from the C language structure and send the encapsulated input data to the command byte stream, and unpack the response in the response byte stream format to the C language structure. The System API interfaces include TCM _ CreatePrimaryKey, TCM _ XML _ CreateKey, TCM _ XML _ CreatePrimaryKey, Tspi _ TCM _ Clear, Tspi _ TCM _ CreatePrimary, check _ TCM _ chip _ resource, handle _ TCM _ chip _ resource, and the like. And modifying the source code of the corresponding function in the Trousers-TCM software stack by using a System API interface, modifying the parameter format, the data command protocol and the encapsulation and analysis of the parameter to realize the corresponding function again, and transplanting according to the mode.

Further, the design idea of optimizing the System API interface is as follows:

1. executing TCM commands: the System API function typically executes a TCM command.

2. The System API will implement the functions and response layout of the trusted TCM chip command line as much as possible, with the function input and output parameters sorted according to the way displayed in the command line parameters, with the variable names matched as much as possible.

3. Memory requirements for input and output parameters:

a: all output parameters need to pass pointers to the System API.

B: to minimize stack memory requirements, the input of a non-simple data type or bit field will be passed as a pointer.

C: buffers for the input command byte stream and the output response byte stream are allocated as part of the context structure to minimize the use of function stack space.

4. The System API implementation will do as much work as possible for the caller. Examples are as follows:

a: the command byte size field of all commands has the System API to implement dynamic computation.

B: the output parameters will be ungrouped into the C language structure before being returned to the caller so that the caller can read the fields directly from them.

Further, in this embodiment, the optimization means is to simplify the System API interface parameters by encapsulating the System API interface parameters.

The System API interface parameter simplification comprises the step of simplifying System API interface parameters by using an XML module for a part of interfaces, the XML module encapsulates the parameters by using XML files to form a template, the parameters are further simplified, a user can conveniently use interfaces with more complex parameters (such as key interface creation), the System API interface parameter simplification is a good supplement for the Feature API interface and is positioned in a Feature API interface layer of a trusted TCM software stack.

Simplifying System API interface parameters by using an XML module: the most complicated parameter in all interfaces is to create a key interface, wherein the public key parameters of the key are flexible, and different types of keys can be created by different public key parameters, such as keyedHash type keys, AES type keys, SM4 type keys, SM2 type keys, RSA type keys, SIGN type keys, and the like. The XML template of the AES encryption/decryption key is as follows.

<frame>

<data〉

</data>

</inSensitive>

<type>TCIM_ALG_SYMCIPHER</type>

<fixedTCM>1</fixedTCM〉

<sensitiveDataOrigin>1</sensitiveDataOrigin〉

<noDA>0</noDA〉

<sign>0</sign〉

</objectAttributes>

</authPolicy>

<algorithm>TCM_ALG_AES</algorithm

</symDetai1>

</parameters〉

<sym〉

<buffer/〉

</sym〉

</unique>

</inPublic>

</outsideInfo>

</creationPcr>

</frame>

The following example illustrates the simplified procedure of TCM _ createprimary key interface in the System API interface.

The System API interface, such as the TCM _ createprimary key interface, is used to create a master key, return a master key handle, where the key is a temporary key, and is automatically cleared after the chip is restarted. Interface definition:

int TCM_CreatePrimaryKey(

TSS_HCONTEXT hContext， /*in*/

Key_Detail *key， /*in*/

UINT32 *objectHandle， /*out*/

Buffer_Detail *creation_hash_detail， /*out*/

Buffer_Detail *name_detail， /*out*/

TCM2B_PUBLIC *outPublic， /*out*/

TCM2B_CREATION_DATA *creationData， /*out*/

TCMT_TK_CREATION *creationTicket /*out*/

);

inputting parameter description: [1] hContext: context handle

[2] key: a hierarchical object structure;

wherein the key structure body:

typedef struct {

UINT32 objectHandle;

Session_Data_In_Detail session_data_in_detail;

Sensitive_Detail sensitive_detail;

Public_Detail public_detail;

Outside_Info_Detail outside_info_detail;

TCML_PCR_SELECTION creationPcr;

}Key_Detail；

objectHandle: the level of the specified hierarchy (TCM _ RH _ OWNER, TCM _ RH _ NULL,

TCM_RH_ENDORSEMENT，TCM_RH_PLATFORM）；

session _ data _ in _ detail _ data: a random number, typically 0;

session _ data _ in _ detail. hmac _ data: the specified level of authorization data; (maximum value 64 bytes)

session _ data _ in _ detail. session attributes: an authorization attribute, typically 0;

session _ data _ in _ detail. Authorization mode, generally using password authorization mode;

(TCM _ RS _ PW), some interfaces need to use policy authorization (e.g., key migration interface);

systematic _ detail.usrauth _ data: customizing authorization data of the object; (maximum value 64 bytes)

Passive _ detail. usrdata _ data: customizing confidential data of the object; (maximum value 128 bytes)

public _ detail.public _ type: an algorithm specifying an object;

public _ detail.public _ nameAlg: specifying a hash algorithm for calculating object name data;

public _ detail _ audio _ policy _ detail: policy authentication data specifying the object; (maximum value 64 bytes)

public _ detail, public _ keyedHash _ parss: parameters of a keyedHash type key;

public _ detail.public _ sym _ parts: parameters for sym-type keys;

public _ detail, public _ rsa _ parms: rsa parameters for type keys;

public _ detail.public _ ecc _ parts: parameters of the ecc type key;

public _ detail.public _ asym _ parms: parameters of the asym-type key;

public _ detail _ unique _ detail: a unique identifier specifying an object; (keyedHash and symciper algorithm maximum value 64 bytes; RSA algorithm maximum value 256 bytes; ECC algorithm maximum value 32 bytes)

out _ info _ detail: permanent data specifying the object; (maximum value 64 bytes)

creationPcr: specifying an associated PCR for the object;

output parameter description [1] objectHandle: outputting the created key handle;

[2] creation _ hash _ detail: creating a data hash result;

[3] name _ detail: key name data;

[4] outpubic: public part data of the key;

[5] creationData: creating data;

[6] creationTicket: verifying that the creation data is a tag generated by TCM by using TCM _ CertifyCreation ();

return parameter = =0 succ! =0 error

It can be known from the above interface definition that the key hierarchical object structure of the input parameter is very complicated, it is very easy to make mistakes to assign data, utilize XML file to encapsulate the hierarchical object structure, form the template file (AES encrypts the XML template of the decryption key), modify the XML file directly and can be direct-viewing and convenient to assign value, it is difficult to make mistakes, realize simplifying and perfecting interface TCM _ CreatePrimaryKey parameter, the interface is modified to TCM _ XML _ CreatePrimaryKey, and replace the corresponding functional interface in Trouiser-TCM software stack, the new interface definition:

int TCM_XML_CreatePrimaryKey(

TSS_HCONTEXT hContext， /*in*/

primaryAuth_st *pri_auth， /*in*/

userAuth_st *usr_auth， /*in*/

const char *xml_patch， /*in*/

TCM_HANDLE *objectHandle， /*out*/

TCM2B_PUBLIC *outPublic， /*out*/

TCM2B_CREATION_DATA *creationData， /*out*/

TCM2B_DIGEST *creationHash， /*out*/

TCMT_TK_CREATION *creationTicket， /*out*/

TCM2B_NAME *name /*out*/

);

the input parameters describe [1] hContext: context handle

[2] pri _ auth: specifying a hierarchy and a hierarchical authorization data structure;

[3] usr _ auth: customizing an authorization data structure of the generated key object;

[4] xml _ patch: specifying an absolute path name of the xml template;

[2] outpubic: public part data of the key;

[3] creationData creating data;

[4] creationHash: creating a data hash result;

[5] creationTicket: verifying that the creation data is a tag generated by TCM by using TCM _ CertifyCreation ();

[6] name: key name data;

return parameter = =0 succ! =0 erro

The existing trusted software stack is generally used directly by the open source software stack or slightly modified. The trusted TCM chip resource space is small, great limitation is brought to application layer use, and the access utilization of an upper layer software stack interface to trusted TCM chip resources needs to be improved. Some interfaces (such as creating a key interface) have complicated parameters, so that it is difficult for a general user to fill in the parameters correctly, and the requirements of the interfaces for the parameters are very strict, so that errors can be caused if the parameters slightly do not meet the requirements, and calling errors can be caused.

By adopting the trusted TCM software stack designed by the design method, upper-layer applications in a domestic operating system can perform communication interaction with the trusted TCM chip through the trusted TCM software stack, so that trusted calculation is realized, the integrity and authenticity of data are ensured, tampering attack is resisted, codes can be safely executed, the confidentiality of sensitive data is protected, and the like. By transplanting a System API interface to a Troousers software stack, multi-user and multi-level access to the trusted TCM chip is realized. Resource management of the trusted TCM chip is added in a Tcs layer of a Trouiser software stack, so that the bottleneck of limited resources of the trusted TCM chip is better solved, and the utilization rate of the trusted TCM chip resources by a user is improved. And a Least Recently Used (LRU) algorithm is adopted in the trusted TCM chip resource management module to schedule the trusted TCM chip resources, so that the access utilization rate of an upper layer interface to the trusted TCM chip resources is improved. The XML file is used for packaging the hierarchical object structure body of the interface to form a template file, the XML file can be directly and conveniently assigned by being modified, errors are not prone to occurring, and interface parameters are simplified and improved.

Referring to fig. 5, an embodiment of the present application further provides a trusted TCM software stack System based on a Linux operating System, which is implemented based on the above design method and includes a Feature API interface layer and a trouser-TCM software stack, where the trouser-TCM software stack includes a System API interface layer, a resource management module, and a Tddl layer, which are arranged from top to bottom, and the System API interface layer includes a Tspi layer, a Tcsd layer, and a Tcs layer, which are arranged from top to bottom; the Feature API interface layer is used for encapsulating input parameters and simplifying a parameter structure; the Tspi layer is used for converting the character strings of the parameters and sending the character strings to the Tcsd layer in a data packet form; the Tcsd layer is used for completing initialization work, receiving a data packet sent by the Tspi layer and sending the data packet to the Tcs layer; the Tcs layer is used for receiving and analyzing a data packet sent by the Tcsd layer, acquiring parameter information, and then carrying out command format encapsulation on the parameter information through the bottom layer interface; the resource management module is used for dynamically detecting and scheduling trusted TCM chip resources by adopting a least recently used algorithm; the Tddl layer is used for completing data transmission through the device file and the trusted TCM chip.

Referring to fig. 6, a trusted TCM software stack data processing flow is described: when the application layer calls the Feature API interface, the Tspi interface of the Troousers-TCM software stack is called after parameter encapsulation is completed, data conversion of the parameters is completed, and the data is sent to a Tcsd layer service program; after the Tcsd layer service program receives the data, each parameter is acquired again through data analysis; calling a Tcs layer interface to perform format conversion and encapsulation of a re-command on the parameter, adding a resource management module for a current trusted chip in a Tcs layer, detecting and allocating resources of the current trusted TCM chip before using the trusted TCM chip, continuing to execute the operation of the current interface after the trusted chip resources meet the current operation requirement, and recording the processed result.

The following embodiments are used for the actual installation of the trusted TCM software stack.

Loading TCM drivers

Installing a TCM driver module, loading the TCM driver module into a kernel, and executing a command:

# insmod ax99100_spi.ko

and installing a TSM software package libTCMalg and Troousers-TCM.

trouser-TCM-0.3.4: trusted TCM software stack.

libTCMalg-1.0: and providing an encryption and hash algorithm, and calling by Trouiser-TCM.

Installation test tool TCM-tools

The TCM-tool is a tool kit for a user or an application program to use TCM, and can set the enablement of the trusted TCM chip, including commands for managing and diagnosing the trusted TCM chip. The commands are communicated and interacted with the trusted TCM chip through the trusted TCM software stack, TCM application management is tested, and the commands comprise TCM enabling operation, TCM non-operation, TCM self-information display, TCM self-checking, starting and the like.

The version information of the trusted TCM chip can be normally displayed as follows:

[root@localhost ~]# TCM_version

TCM Version: 060b0000

Manufacturer Info: 4e545a00

TCM self-test, executing the command TCM _ selftest-r as follows:

[root@localhost ~]# TCM_selftest -r

TCM Self Test Results:OK!

executing TCM _ getpubek, we can look at the ek public key as follows:

[root@localhost ~]# TCM_getpubek

Enter owner password:

Public Endorsement Key:

Version: 00150000

Usage: 0x0002 (Unknown)

Flags: 0x00000000

AuthUsage: 0x00 (Never)

Algorithm: 0x0000000b (TCM SM2)

Encryption Scheme: 0x00000006 (TCM Sm2)

Signature Scheme: 0x00000001 (None)

Key Size: 520bits

Public Key:

04a915bb 43b77298 140aac59 e388a8b8 bb1006b2 0c894587 b7da21ee 17d97220

02136342 94924fc4 d379f126 a5960983 9dec1d10 fc1d6182 7e432e4d e79cc01635

executing TCM _ takeownership may obtain owner as follows:

[root@localhost ~]# TCM_takeownership

Enter owner password:

Confirm password:

Enter SRK password:

Confirm password:

TCM Set Password Successfully。

the trusted TCM software stack of the embodiment enables upper-layer applications in a domestic operating system to perform communication interaction with the trusted TCM chip through the trusted TCM software stack, so that trusted computing is realized, integrity and authenticity of data are guaranteed, tampering attack is resisted, codes can be safely executed, confidentiality of sensitive data is protected, and the like. By transplanting a System API interface to a Troousers software stack, multi-user and multi-level access to the trusted TCM chip is realized. Resource management of the trusted TCM chip is added on a Tcs layer of a Troousers software stack, so that the bottleneck of limited resources of the trusted TCM chip is better solved, and the utilization rate of the trusted TCM chip resources by a user is improved. And a Least Recently Used (LRU) algorithm is adopted in the trusted TCM chip resource management module to schedule the trusted TCM chip resources, so that the access utilization rate of an upper layer interface to the trusted TCM chip resources is improved. The hierarchical object structure of the interface parameters is encapsulated by the XML file to form a template file, and the XML file can be directly and conveniently assigned by being directly modified, so that errors are not easy to occur, and the simplification and the improvement of a complex interface are realized.

The technical terms and abbreviations involved in the embodiments of the present invention are explained as follows:

TPM: trusted computing relies on a Trusted Platform Module (Trusted Platform Module);

TCM: a Trusted Cryptography Module (Trusted Cryptography Module);

TSM: the TCM Service Module (TCM Service Module), the TSM is composed of three software modules, namely TCM application Service (TCM Service Provider, TSP), TCM Core Service (TCS), and TCM Device Driver Library (TCM Device Library, TDDL);

API: application Programming Interface (api) is some predefined interfaces (such as function, HTTP Interface), or refers to the agreement for the connection of different components of the software system;

XML: the extensible markup language, a subset of standard universal markup languages, XML for short, is a markup language for marking electronic documents to have a structure;

trouser software stack: a set of open source software stack realized by IBM is a main interface for trusted computing application development under Linux.

It is to be understood that the above-described embodiments of the present invention are merely illustrative of or explaining the principles of the invention and are not to be construed as limiting the invention. Therefore, any modification, equivalent replacement, improvement and the like made without departing from the spirit and scope of the present invention should be included in the protection scope of the present invention. Further, it is intended that the appended claims cover all such variations and modifications as fall within the scope and boundary of the appended claims, or the equivalents of such scope and boundary.

Claims

1. A design method of a trusted TCM software stack based on a Linux operating system is disclosed, the trusted TCM software stack comprises a Feature API interface layer and a Troousers-TCM software stack, and is characterized by comprising the following steps:

2. The method for designing a trusted TCM software stack based on a Linux operating system according to claim 1, wherein the resource management module is further configured to detect and schedule trusted TCM chip resources by using a least recently used algorithm when loading the subkey, and the method comprises:

3. A design method of a trusted TCM software stack based on a Linux operating System as in claim 1, wherein the trouser-TCM software stack comprises a System API interface after migration and optimization.

4. A method for designing a trusted TCM software stack based on a Linux operating System as recited in claim 3, wherein the step of migrating a System API interface to the trouser-TCM software stack comprises:

and modifying a source code in the Troursers-TCM software stack by using the System API interface to realize a corresponding function again, wherein the source code comprises a parameter format, a data command protocol, a parameter packaging and analyzing code, and the corresponding function comprises key creation and key handle acquisition.

5. A design method of a trusted TCM software stack based on a Linux operating System according to claim 4, wherein the step of optimizing the System API interface is:

and encapsulating the System API interface parameters.

6. The design method of the trusted TCM software stack based on the Linux operating System as recited in claim 5, wherein said encapsulating System API interface parameters comprises:

7. A trusted TCM software stack System based on a Linux operating System is characterized by comprising a Feature API (application program interface) layer and a Troousers-TCM software stack, wherein the Troousers-TCM software stack comprises a System API layer, a resource management module and a Tddl layer which are arranged from top to bottom, and the System API layer comprises a Tspi layer, a Tcsd layer and a Tcs layer which are arranged from top to bottom; wherein the content of the first and second substances,

the resource management module is used for dynamically detecting and scheduling trusted TCM chip resources by adopting a least recently used algorithm, and comprises the following steps:

if the chip resources are not full, directly packaging a command data packet for creating the master key and performing subsequent steps;