Secure verifiable federal segmentation learning method based on trusted execution environment

Abstract

The invention discloses a secure verifiable federated segmentation learning method based on a trusted execution environment, and belongs to the field of federated learning. According to the method, a learning framework is provided, a trusted execution environment is introduced, and transparent and trusted behaviors of the server in the model aggregation and neural network intermediate layer training process are ensured through a strong isolation and proving mechanism. Meanwhile, the user data is protected by adopting a symmetric encryption technology, and the server is prevented from tampering the data. The model is divided into three parts, and the foremost model part and the last model part are stored in the client, so that user data privacy including data labels is effectively protected. In addition, the advantages of federal learning and segmentation learning are combined, a client is allowed to asynchronously train a local model, calculation and communication overhead is reduced, dependence on a server is reduced, and system efficiency and expandability are improved. The innovation not only enhances the security and credibility of the system, but also protects the privacy of the user, and has a wide application prospect.

Description

Technical Field

[0001] The present invention is based on federated learning technology, studies a method combined with segmented learning, and verifies based on a trusted execution environment. The present invention belongs to the field of federated learning, and specifically relates to key negotiation, signature and other technologies. Background Art

[0002] Federated learning, as a machine learning paradigm that can complete tasks without exposing user privacy, has attracted significant attention in an era of increasing emphasis on privacy. In recent years, many related studies and methods have been proposed, which have greatly promoted the development of this field. Federated learning is designed in a form that does not require direct data exchange or collection, thereby protecting user privacy. In addition, this approach enables multiple participants to jointly train machine learning models, allowing data owners to achieve better models than training alone.

[0003] Federated learning and split learning are two widely recognized methods in the field of distributed machine learning. Federated learning involves training a complete machine learning model on distributed clients using their local data, and then aggregating the locally trained models into a global model on the server. Split learning, on the other hand, involves dividing the complete machine learning model into multiple smaller neural network fragments, and then training them separately on the server and distributed clients.

[0004] The main limitation of federated learning is that each client must perform the training of the entire machine learning model, which is a challenge for resource-constrained clients such as devices in the Internet of Things. Split learning frameworks address this issue by offloading part of the model training from the client to the server, enabling low-end devices to participate in deep learning tasks. In addition, in federated learning, there are privacy concerns related to model confidentiality during training, as the server has access to the local full model uploaded by the client.

[0005] It is extremely important to combine federated learning with segmented learning to fully exploit the advantages of each method. However, this also brings challenges, especially in ensuring that the behavior of the server can be verified. For example, a "lazy" cloud service provider may compress the original model into a simpler and less accurate version to reduce computational costs, or even maliciously tamper with the aggregated results before sending them back to the user.

[0006] A trusted execution environment establishes a secure area (often called an "enclave") within the main processor to provide strong confidentiality and integrity guarantees for the data and code stored or processed. The trusted execution environment achieves strong isolation and attestation of the secure area by implementing a dual-world architecture, in which even compromised or malicious privileged software in the normal world (called the "rich OS execution environment") cannot access the secure world. Applying a trusted execution environment to ensure the security of deep learning tasks is an efficient and promising approach. Summary of the invention

[0007] The main content of this invention is a verifiable federated learning framework combined with split learning, and uses a trusted execution environment to verify server computing. In the scenario where federated learning and split learning are combined, there is currently no method provided to users to verify the server computing results, which is a very meaningful challenge in the common lazy server scenario. In addition, solutions based on trusted execution environments are also areas that need attention, and how to use such technology and secure enclaves for trusted computing is also a very meaningful work. To achieve this research, the following main problems need to be solved, which are the content of this invention:

[0008] (1) Utilizing a trusted execution environment, the present invention proposes a scheme for verifying server behavior in the context of federated segmented learning, including the server's aggregation process of client models and the training process of a partial neural network on the server side.

[0009] (2) In the scenario of federated segmented learning, the present invention uses symmetric encryption technology to protect the confidentiality of the client model and prevent the server from tampering with the transmitted data content. By segmenting the model into three parts, the privacy of the user's original data and data labels is effectively protected.

[0010] (3) The present invention fully utilizes the advantages of federated learning and segmented learning, enabling the client to asynchronously train the local model while reducing computational and communication overhead.

[0011] Compared with the prior art, the present invention has the following obvious advantages and beneficial effects:

[0012] First, by introducing a trusted execution environment, the present invention realizes the verification of server behavior under the framework of federated segmented learning, including the verification of the aggregation process of the client model and the training process of the intermediate layer of the neural network in segmented learning, which greatly enhances the security and credibility of the system.

[0013] Secondly, the present invention innovatively uses symmetric encryption technology in the scenario of federated segmented learning to protect user data. This measure ensures that even if there is collusion between the server and some users, the original data of honest users cannot be inferred through the aggregated model information, effectively protecting the user's privacy data.

[0014] In addition, the present invention combines the advantages of federated learning and split learning, allowing the client to asynchronously train the local model. This feature greatly reduces the client's dependence on the server in the split learning scheme and reduces the number of communications and data transmission between the client and the server or between different clients. This improvement is particularly critical for resource-constrained clients (such as IoT devices), which enables these devices to participate in deep learning tasks more efficiently. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] Figure 1 System model diagram DETAILED DESCRIPTION

[0016] According to the above description, the following is a specific implementation process, but the scope of protection of this patent is not limited to this implementation process.

[0017] Phase 1: System Presets

[0018] First, the trusted authority generates the public parameters PP including the commitment parameter PPcom, and assigns a public-private key pair (pk i ,sk i ), assigning (pk e ,sk e ). The public key is publicly accessible, while the private key is kept secret. In addition, the trusted authority divides the complete model into the initial layer m i 、Middle layer m and the final layer m f The initial and final layers are delivered to each client, while the intermediate layers are distributed to the trusted execution environment on the server side.

[0019] Phase 2: Forward Propagation

[0020] All clients perform forward propagation on their client models in parallel, feeding the raw data into m i and generates the output forward tensor FT i Each client i generates a symmetric key based on the secure key agreement protocol (KA) and the trusted execution environment, as shown below:

[0021] k i,e =KA(sk i ,pk e )=KA(sk e ,pki ) = k e,i

[0022] where k i,e Indicates the key generated by client i using its own private key and the public key of the trusted execution environment, k e,i represents the key generated using the private key of the trusted execution environment and the public key of client i. Subsequently, each client i encrypts the forward tensor FT using the symmetric key i :

[0023] FT′ i,e =Encrypt(k i,e ,FT i )

[0024] Among them, Encrypt is the encryption operation of the symmetric encryption protocol, FT′ i,e Represents the encrypted forward tensor sent by client i to the trusted execution environment. Afterwards, it is signed as follows:

[0025] σ i =Sign(sk i ,FT′ i,e )

[0026] Among them, Sign represents the signature operation, σ i Represents the signature generated by client i.

[0027] The server receives {FT′ i,e ,σ i} i∈N , and continue to process the forward propagation of the server-side model, where N represents the set of all clients. The encrypted tensor and signature from client i are input into the trusted execution environment, where they can be verified and decrypted as follows:

[0028] VreSig(pk i ,FT′ i,e ,σ i )? =True

[0029] FT i,e =Decrypt(k e,i ,FT′ ,e )

[0030] Where, ? = indicates whether it is equal to the operation, VerSig indicates the signature verification operation, and Decrypt is the decryption operation of the symmetric encryption protocol. m After forward propagation is performed, the trusted execution environment outputs the forward tensor FT e,i , which is then encrypted and signed for client i as follows:

[0031] FT′ e,i =Encrypt(k e,i ,FT e,i )

[0032] σ e =Sign(sk e ,FT′ e,i )

[0033] Among them, FT′ e,i Represents the encrypted forward tensor sent by the trusted execution environment to client i.

[0034] In Decrypting FT′ e,i Previously, client i verified VerSig(pk e ,FT′ e,i ,σ e )=True to confirm that the forward propagation process is indeed executed in a trusted execution environment. Finally, client i sends FT e,i Spread to m f And generate gradients.

[0035] Phase 3: Back Propagation

[0036] Entering the back-propagation phase, client i propagates the loss to m f , until it reaches the frontmost layer of this model part and outputs the reverse gradient BG i Similar to the forward propagation stage, client i outputs the reverse gradient BG i Perform encryption and signing operations as shown below, and then upload it to the server.

[0037] BG′ i,e =Encrypt(k i,e ,BG i )

[0038] σ i =Sign(sk i ,BG′ i,e )

[0039] Among them, BG′ i,e Represents the encrypted reverse gradient sent by client i to the trusted execution environment. i has been verified, so we use the same notation here as in the forward propagation phase to represent the signature of client i.

[0040] After receiving the encrypted reverse gradient and signature, the trusted execution environment verifies the signature and decrypts it. Then, the decrypted gradient is used to execute in m m Perform back propagation on m mThe reverse gradient of the output is denoted as BG e,i In the back-propagation phase, the information sent by the trusted execution environment to client i includes the encrypted reverse gradient BG′ e,i =Enrypt(k e,i ,BG e,i ) and the corresponding signature σ e =Sign(sk e ,BG′ e,i ).

[0041] At this point, the trusted execution environment can continue to process the forward propagation phase of the next client without waiting for the response of the current client.

[0042] In verifying σ e And decrypt BG′ e,i After that, client i will BG e,i Perform backpropagation and update the local model to complete this round of training.

[0043] Phase 4: Model aggregation

[0044] When all clients complete forward propagation and back propagation in round r, the system will start the model aggregation phase. Let PPcom = (g, h) be the public parameters for commitment, where in, is a cyclic group, (g1,…,g d ) are d different generators and h is a randomly chosen group element.

[0045] First, each client i generates rand i =PRF(k i,e ,r), where PRF is a cryptographically secure pseudo-random function and r is the current round number. Subsequently, client i uses the extended Pedersen commitment scheme to its local model x i =m i ||m f Make a promise as shown below. || represents a concatenation operation.

[0046]

[0047] The commitment is then signed.

[0048] σ i =Sign(sk i ,com i )

[0049] Next, each client i establishes a key negotiation with other clients:

[0050] k i,j =KA(ski ,pk j )for j∈N

[0051] Where N represents the set of all clients. Then, x is calculated as follows i Perform masking:

[0052]

[0053] Among them, PRG is a cryptographically secure pseudo-random generator that accepts a uniform random seed of fixed length and outputs a string that is computationally indistinguishable from a random string.

[0054] Upon receiving Finally, considering the limited memory available in the trusted execution environment, the server aggregates all mask models in the rich execution environment. In the case of correct aggregation, the additional masks will be completely offset, resulting in a correct aggregation result. At the same time, {com i ,σ i} i∈N is loaded into the Trusted Execution Environment and performs the following operations:

[0055] confirm

[0056] Calculate rand = ∑ i∈N rand i =∑ i∈N PRF(k e,i ,r)

[0057] Calculate com = ∏ i∈ Ncom i

[0058] Signature e =Sign(sk e ,com||rand)

[0059] Output τ=(σ e ,com,rand)

[0060] Where r is the current round number, and τ represents the information set output by the trusted execution environment.

[0061] Afterwards, the server sends τ and x to all clients, who then check the signature VerSig(pk e ,com||rand,σ e )? = True. Once com and rand are verified,

[0062] Each client i finally verifies the aggregation result as follows:

[0063] com?=g x h rand 。

Claims

1. A secure and verifiable federated segmentation learning method based on a trusted execution environment, characterized by: The three participants are the trusted authority, the server containing the trusted execution environment, and the client; the trusted authority's initialization system provides the segmented model and distributes it to the client and server, generates parameters, and assigns public and private key pairs to each participant; subsequently, it will remain offline unless a dispute occurs; the tasks of the server containing the trusted execution environment include training the middle-layer model, aggregating client models and computing, and transmitting information; The specific steps are as follows: Phase 1: System Presets First, the trusted authority generates the public parameters PP including the commitment parameter PPcom, and assigns a public-private key pair (pk i ,sk i ), assigning (pk e ,sk e ); The public key is publicly accessible, while the private key must be kept secret; in addition, the trusted authority divides the complete model into the initial layer m i 、Middle layer m and the final layer m f ;The initial and final layers are transmitted to each client, while the intermediate layers are assigned to the trusted execution environment on the server side; Phase 2: Forward Propagation All clients perform forward propagation on their client models in parallel, feeding the raw data into m i and generates the output forward tensor FT i ; Each client i generates a symmetric key based on the secure key agreement protocol (KA) and the trusted execution environment, as shown below: to i,e =KA(sk i ,pk e )=KA(en e ,pk i )=k e,i where k i，e Indicates the key generated by client i using its own private key and the public key of the trusted execution environment, k e，i represents the key generated using the private key of the trusted execution environment and the public key of client i; then, each client i encrypts the forward tensor FT using the symmetric key i : FT′ i，e =Encrypt(k i，e ,FT i ) Among them, Encrypt is the encryption operation of the symmetric encryption protocol, FT′ i,e Represents the encrypted forward tensor sent by client i to the trusted execution environment; then, it is signed as follows: σ i =Sign(sk i ,FT i,e ) Among them, Sign represents the signature operation; σ i represents the signature generated by client i; The server receives {FT′ i，e , σ i } i∈N , and continue to process the forward propagation of the server-side model, where N represents the set of all clients; the encrypted tensor and signature from client i are input into the trusted execution environment, where they can be verified and decrypted, as shown below: VerSig(pk i ,FT′ i，e ,σ i )?=True FT i，e =Decrypt(k e，i ,FT′ i，e ) Where, ? = indicates whether it is equal to the operation, VerSig indicates the signature verification operation, and Decrypt is the decryption operation of the symmetric encryption protocol; m After forward propagation is performed, the trusted execution environment outputs the forward tensor FT e，i , which is then encrypted and signed for client i as follows: FT′ e，i =Encrypt(k e，i ,FT e，i ) σ e =Sign(sk e ,FT′ e,i ) Among them, FT′ e，i represents the encrypted forward tensor sent by the trusted execution environment to client i; In Decrypting FT′ e，i Previously, client i verified VerSig(pk e , FT′ e，i , σ e )=True to confirm that the forward propagation process is indeed executed in a trusted execution environment; finally, client i will FT e，i Spread to m f And generate gradients; Phase 3: Back Propagation Entering the back-propagation phase, client i propagates the loss to m f , until it reaches the frontmost layer of this model part and outputs the reverse gradient BG i ; Similar to the forward propagation stage, client i outputs the reverse gradient BG i Perform the encryption and signing operations as shown below, and then upload it to the server; BG′ i，e =Encrypt(k i，e ,BG i ) σ i =Sign(sk i ,BG′ i,e ) Among them, BG′ i，e Represents the encrypted reverse gradient sent by client i to the trusted execution environment; due to the previous signature σ i It has been verified, so the same symbol as in the forward propagation stage is used here to represent the signature of client i; After receiving the encrypted reverse gradient and signature, the trusted execution environment verifies the signature and decrypts it; then uses the decrypted gradient to execute in m m Perform back propagation on m m The reverse gradient of the output is denoted as BG e , i; In the back-propagation phase, the information sent by the trusted execution environment to the client i includes the encrypted reverse gradient BG′ e，i =Encrypt(k e，i , BG e，i ) and the corresponding signature σ e =Sign(sk e , BG′ e，i ); At this point, the trusted execution environment does not need to wait for the response of the current client and continues to process the forward propagation phase of the next client; In verifying σ e And decrypt BG′ e，i After that, client i will BG e，i Perform backpropagation and update the local model to complete this round of training; Phase 4: Model aggregation When all clients complete forward propagation and backpropagation in round r, the system will start the model aggregation phase; let PPcom = (g, h) be the public parameters for commitment, where in, is a cyclic group, (g1,…,gd) are d different generators, and h is a randomly chosen group element; First, each client i generates rand i =PRF(k i，e , r), where PRF is a cryptographically secure pseudo-random function and r is the current round number; then, client i uses the extended Pedersen commitment scheme to its local model x i =m i ||m f Make a commitment as shown below; || indicates a concatenation operation; Then sign the commitment: σ i =Sign(sk i ,with i ) Next, each client i establishes a key negotiation with other clients: to i，j =KA(sk i ,pk j )for j∈N Where N represents the set of all clients; then, x is calculated as follows i Perform masking: PRG is a cryptographically secure pseudo-random generator; Upon receiving After that, the server aggregates all mask models and obtains the aggregated result At the same time, {com i , σ i } i∈N is loaded into the Trusted Execution Environment and performs the following operations: confirm Calculate rand = ∑ i∈N rand i =∑ i∈N PRF(k e，i , r) Calculate com = Π i∈N com i Signature e =Sign(sk e ,com||rand) Output τ=(σ e (com,rand) Where r is the current round number, τ represents the information set output by the trusted execution environment; Afterwards, the server sends τ and x to all clients, who then check the signature VerSig(pk e ,com||rand,σ e )? = True; Once com and rand are verified, each client i finally verifies the aggregate result as follows: com?=g x h rand 。

Images