Data processing method for privacy protection and model training device

Abstract

A model training method and device for privacy protection. The model training device comprises a TEE, a first algorithm being loaded in the TEE. The method comprises: receiving a plurality of pieces of ciphertext sample data; storing the plurality of pieces of ciphertext sample data outside of a TEE; and the TEE performing the following operations in a loop: acquiring several pieces of ciphertext sample data among the plurality of pieces of ciphertext sample data from outside of the TEE and storing same in a memory within the TEE, decrypting the several pieces of ciphertext sample data to obtain several pieces of plaintext sample data, running a first algorithm on the basis of the several pieces of plaintext sample data, updating current parameters of a first model to obtain first parameters of the first model, storing the first parameters as the current parameters of the first model, and deleting the several pieces of ciphertext sample data.

Description

A data processing method and model training device for privacy protection

[0001] This application claims priority to the Chinese patent application filed with the State Intellectual Property Office of China on September 28, 2023, with application number 202311285059.5 and application name “A data processing method and model training device for privacy protection”, the entire contents of which are incorporated by reference into this application. Technical Field

[0002] The embodiments of this specification belong to the field of computer technology, and in particular, relate to a data processing method and model training device for privacy protection. Background Art

[0003] A Trusted Execution Environment (TEE) is a hardware-secured, trusted execution environment within a computing device. A TEE provides an isolated execution environment, ensuring that code and data running within the TEE are not interfered with by the regular operating system. This ensures the security, confidentiality, and integrity of the code and data stored within the TEE.

[0004] Summary of the Invention

[0005] The purpose of the present invention is to provide a data processing method for privacy protection, so as to improve the efficiency of algorithm development within TEE.

[0006] In a first aspect, this specification provides a model training method for privacy protection, which is performed by a model training device, wherein the model training device includes a trusted execution environment (TEE), wherein a first algorithm is loaded in the TEE, and the first algorithm is used to train a first model. The method includes:

[0007] Receive multiple ciphertext sample data;

[0008] Storing the plurality of ciphertext sample data outside the TEE;

[0009] The TEE loop performs the following operations: obtaining some ciphertext sample data from the multiple ciphertext sample data from outside the TEE and storing them in the memory within the TEE, decrypting the some ciphertext sample data to obtain some plaintext sample data, running the first algorithm based on the some plaintext sample data, updating the current parameters of the first model to obtain the first parameters of the first model, storing the first parameters as the current parameters of the first model, and deleting the some ciphertext sample data.

[0010] A second aspect of this specification provides a model training device, the model training device including a trusted execution environment (TEE), wherein the TEE is loaded with a first algorithm, the first algorithm being used to perform model training on a first model, the model training device including:

[0011] A receiving unit, configured to receive a plurality of ciphertext sample data;

[0012] A storage unit, configured to store the plurality of ciphertext sample data outside the TEE;

[0013] A training unit is used to enable the TEE to loop and perform the following operations: obtain some ciphertext sample data from the outside of the TEE and store them in the memory within the TEE, decrypt the some ciphertext sample data to obtain some plaintext sample data, run the first algorithm based on the some plaintext sample data, update the current parameters of the first model to obtain the first parameters of the first model, store the first parameters as the current parameters of the first model, and delete the some ciphertext sample data.

[0014] A third aspect of this specification provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed in a computer, the computer is caused to execute the method described in the first aspect.

[0015] The fourth aspect of this specification provides a model training device, including a memory and a processor, wherein the memory stores executable code, and when the processor executes the executable code, the method described in the first aspect is implemented.

[0016] In the data processing method provided in the embodiments of this specification, the TEE obtains a number of encrypted sample data from outside the TEE in multiple cycles to train the model. Even when the TEE's memory is small, the model training process based on big data can still be performed, thereby achieving the completion of the model training process while protecting the user privacy in the sample data. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the technical solutions of the embodiments of this specification, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments recorded in this specification. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0018] FIG1 is an architecture diagram of a model training device according to an embodiment of the present specification;

[0019] FIG2 is an architecture diagram of a model training device according to another embodiment of the present specification;

[0020] FIG3 is a flowchart of a method for a TEE to obtain encryption and decryption keys for user data according to an embodiment of this specification;

[0021] FIG4 is a flow chart of a method for model training based on TEE in an embodiment of this specification;

[0022] FIG5 is a schematic diagram of a process of reading data through a read interface in an embodiment of this specification;

[0023] FIG6 is a schematic diagram of a process for providing data to the outside of the TEE through a write interface in an embodiment of this specification;

[0024] FIG7 is an architecture diagram of a model training device in one embodiment of this specification. DETAILED DESCRIPTION

[0025] To help those skilled in the art better understand the technical solutions in this specification, the following will provide a clear and complete description of the technical solutions in the embodiments of this specification, in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of this specification, not all of them. All other embodiments derived by those skilled in the art based on the embodiments in this specification without creative effort shall fall within the scope of protection of this specification.

[0026] A TEE is a trusted execution environment (TEE) based on a secure extension of the CPU hardware, completely isolated from the outside world. Currently, there are various TEE solutions, including the software-based TPM (Trusted Platform Module) and hardware-based SGX (Software Guard Extensions), ARM Trustzone, and AMD PSP (Platform Security Processor). The TEE acts as a black box, preventing even the operating system from intruding on the code and data executed within it. These operations can only be performed through predefined interfaces within the code. Therefore, TEE technology enables trusted computing while protecting private data.

[0027] SGX (Software Guard Extension) is an example of TEE technology. Based on SGX technology, computing devices can create enclaves (enclaves or enclaves) as TEEs for data processing. Using new processor instructions in the CPU, computing devices can allocate a memory area called the EPC (Enclave Page Cache) to host the enclave. The memory area corresponding to the EPC is encrypted by the CPU's internal Memory Encryption Engine (MEE). The contents of this memory area (code and data within the enclave) can only be decrypted within the CPU core, and the encryption and decryption keys are generated and stored in the CPU only when the EPC is started. As can be seen, the enclave's security boundary only includes the enclave itself and the CPU. Neither privileged nor unprivileged software can access the enclave. Even operating system administrators and virtual machine monitors (VMMs, also known as hypervisors) cannot affect the code and data within the enclave, resulting in extremely high security. Under the premise of the above security guarantees, the CPU can process data in the enclave with extremely high computing efficiency, thus taking into account both data security and computing efficiency. In addition, data entering and leaving the TEE is usually encrypted to ensure data privacy.

[0028] In the field of machine learning, model training services can be provided to users through a model training platform. Users can provide sample data to the model training platform, so that the model training platform can perform model training based on the sample data. Sample data usually includes a training sample set and a test sample set. The model training platform can adjust the parameters of the model (such as a clustering model, a neural network model, etc.) based on the training sample set, and use the test sample set to verify the model performance, thereby completing the model training process. Typically, the training sample set and the test sample set have a large amount of data. In addition, the samples include, for example, user feature data, merchant transaction data, production data, etc. Therefore, the samples may include the user's private data. Users usually encrypt the sample data and provide it to the model training platform for model training.

[0029] In related technologies, to further protect user privacy data, model training platforms can use TEE to conduct model training. However, due to the large sample data size and limited memory space within the TEE, it is difficult for the TEE to copy the ciphertext data corresponding to the sample data (i.e., the ciphertext sample set) into the TEE as a whole and decrypt the ciphertext data to obtain the plaintext data (i.e., the plaintext sample set) for model training.

[0030] To this end, an embodiment of this specification provides a method for model training within a TEE, which can solve the problems in the above-mentioned related technologies. Figure 1 is an architectural diagram of a model training device in an embodiment of this specification. Specifically, referring to Figure 1, the user divides the training data into multiple small blocks through the user device, each small block may include, for example, several samples, encrypts each small block, obtains multiple ciphertext sample data, and sends the multiple ciphertext sample data to the model training platform. Specifically, the user device can encrypt each sample in the training data to obtain multiple ciphertext samples, and send the multiple ciphertext samples to the model training platform, which will be described as an example below.

[0031] The model training platform includes a TEE, which is loaded with a model training algorithm and pre-stored with a key for decrypting ciphertext samples. After receiving multiple ciphertext samples, the model training platform can store them in memory outside the TEE. The TEE can then sequentially obtain each ciphertext sample from outside the TEE and perform model training based on each ciphertext sample within the TEE. This allows model training within the TEE to be equivalent to training based on each ciphertext sample through streaming processing. The key features of streaming processing are real-time and continuity. It does not require waiting for all data to be collected before processing; instead, it can process partial data as it is acquired.

[0032] Among them, when training based on a ciphertext sample, the TEE only needs to store a ciphertext sample (such as ciphertext sample 2 in Figure 1) in the TEE for decryption to obtain a plaintext sample, and then train based on the plaintext sample. After obtaining the plaintext sample, the TEE can encrypt it through the MEE as described above to obtain new ciphertext data (such as ciphertext sample 2' in Figure 1), and store the new ciphertext sample in the memory within the TEE for model training. The TEE memory also stores the model parameters of the model to be trained. It can be seen that under this method, a large memory within the TEE is not required, and the model training process can be implemented within the TEE.

[0033] In addition, algorithm developers generally write model training algorithms in high-level programming languages ​​and call file system operation interfaces in the algorithm code. For example, calling Python's file read and write interfaces involves multiple layers of calls to the Python system library, Python virtual machine, C interface, OS interface, etc. However, in a TEE environment such as SGX, only the Software Development Kit (SDK) in the TEE is provided. If algorithm developers develop algorithms to run in the TEE, they need to determine the algorithm code corresponding to the TEE based on the SDK provided in the TEE. This requires algorithm developers to pay attention to the technical details of the TEE when developing algorithms, which increases the burden on algorithm developers.

[0034] For example, in a TEE, data within the TEE is written to the outside of the TEE by calling the ocall function. Furthermore, to ensure data security, all data entering and leaving the TEE is encrypted. When an algorithm reads encrypted data provided from outside the TEE, it first needs to decrypt the encrypted data before processing the decrypted plaintext data. After processing the plaintext data and obtaining a result, the algorithm also needs to encrypt the result to obtain a ciphertext result, which is then stored outside the TEE by calling the ocall function. In related technologies, the algorithm must include code for performing the aforementioned encryption and decryption processing, as well as calling the ocall function, which increases the burden on algorithm developers compared to developing algorithms outside the TEE.

[0035] To this end, in the embodiments of this specification, a TEE operating system (TEE OS) is provided in the TEE to reduce the burden on algorithm developers. The TEE OS provides interfaces such as read and write interfaces corresponding to TEE operations, so that algorithm developers do not need to pay attention to the technical details within the TEE. They can complete the read and write operations corresponding to the TEE by directly calling the interfaces provided by the TEE OS, just like outside the TEE. Among them, data encryption and decryption, calling of ocall functions and other operations are completed by executing the code in the TEE OS, which greatly reduces the burden on algorithm developers.

[0036] Figure 2 is an architectural diagram of a model training device in another embodiment of this specification. As shown in Figure 2, the model training device includes a TEE, and the TEE OS can be loaded first in the TEE. Specifically, the host application in the model training device calls the library function of the TEE OS to load the binary file of the TEE OS into the enclave. This process includes copying the code and data of the TEE OS to the memory space of the enclave and setting the operating environment of the TEE OS. After the Occlum is loaded, the host application will call the startup function of the TEE OS to start executing the TEE OS in the enclave.

[0037] Afterwards, the application (e.g., a model training algorithm) can be loaded and started through the TEE OS in the TEE. Specifically, the TEE uses the TEE OS file system interface to copy the algorithm's binary file and any required data files to the TEE OS file system. The loaded algorithm can then be run through the TEE OS process management interface.

[0038] The TEE OS also includes interfaces such as a read interface, a write interface, and a configuration interface, among which the read interface and the write interface are interfaces that can be called by the algorithm, and the configuration interface is an interface for configuring the algorithm. Based on the TEE OS, when the algorithm developer develops an algorithm to be loaded into the TEE, he can directly call the read interface or write interface provided by the TEE OS in the algorithm to complete the reading or writing of data outside the TEE, thereby greatly reducing the workload of the algorithm developer. When executing, for example, a model training algorithm in the TEE, when executing the read interface called in the model training algorithm, the following operations can be performed according to the read interface: read ciphertext data from outside the TEE, decrypt the ciphertext data using a pre-acquired decryption key, obtain plaintext data, and return the plaintext data to the model training algorithm. When executing the write interface called in the model training algorithm, the following operations can be performed according to the write interface: encrypt the data to be written using a pre-acquired encryption key, obtain ciphertext data, and write the ciphertext data to the outside of the TEE.

[0039] The user can encrypt and decrypt data using a symmetric encryption and decryption algorithm, or an asymmetric encryption and decryption algorithm. The following description uses symmetric encryption and decryption as an example.

[0040] FIG3 is a flow chart of a method for TEE to obtain encryption and decryption keys for user data in an embodiment of this specification.

[0041] As shown in FIG3 , in step S301 , the model training device generates a public key pk and a private key sk.

[0042] In one embodiment, the TEE of the model training device may generate a public key pk and a private key sk in response to a report generation request of the user device.

[0043] Before using the TEE algorithm to process data, the user device can initiate a remote authentication process with the TEE in the model training device. During the remote authentication process, the TEE generates a public-private key pair for encryption and provides the public key to the user device. This process is described in detail below.

[0044] Before leaving the factory, the manufacturer of the SGX-supported CPU will burn the Provisioning Key and Sealing Key into the fuse register in the CPU. The fuse register is a one-time programmable register. Once the data is burned into it, the fuse will be blown, making the subsequent contents of the register only readable but no longer writable. The Provisioning Key can represent some information in the CPU, such as the CPU code (such as the sixth-generation Core, seventh-generation Core, etc.), model (such as desktop, mobile, etc.). For security reasons, encryption, signing and other operations do not directly use the Provisioning Key. Instead, an attestation key derived from the Provisioning Key is used for them. Therefore, the Provisioning Key plays a deployment role.

[0045] Before the user device initiates remote authentication of the TEE in the model training device, the CPU in the model training device can detect whether there is an attestation key. If not, initialization is initiated. During the initialization process, based on the key generation protocol, through interaction with the server and according to the generation rules of the Provisioning Key, an EPID (Enhanced Privacy IDentification) can be generated. The EPID can be used as an attestation key, generally used as the private key sk1 in the asymmetric encryption key. The generated EPID can be stored in the TEE for subsequent signing operations. Thus, the server can obtain the public key pk1 corresponding to the EPID through the interaction process. In particular, the public key pk1 corresponding to the EPID will not be made public and is only kept by the server. Such features are suitable for subsequent authentication by the server (also known as IAS) during the remote attestation process.

[0046] After preparing the private key sk1 and public key pk1 for signing, the TEE can obtain the private key sk2 and public key pk2 for asymmetric encryption through the following steps:

[0047] Step 1: The user device initiates a challenge to the TEE in the model training device to request it to produce a report to prove that the program code included therein is the correct code. Specifically, the report is used to prove that the code in the TEE includes the TEE OS code plus the algorithm code; the user device can send the challenge to the model training device, and the model training device initiates a report generation request based on the challenge and provides the report generation request to the TEE.

[0048] Step 2: After receiving the report generation request, the TEE in the model training device calculates hash1 of the local code, generates the public key pk2 and private key sk2 for encryption, generates a report quote containing hash1 and pk2, and signs the quote using the key sk1, obtaining signature sig1. Specifically, this process is performed by executing the TEE OS in the TEE.

[0049] In step S303, the model training device TEE sends the public key pk2 to the user device.

[0050] The TEE in the model training device can send the quote and its signature sig1 to the user device. Specifically, the TEE OS calls the ocall function in the TEE, writing the quote and signature sig1 outside the TEE, so that the model training device sends the quote and signature sig1 to the user device.

[0051] Because the user device does not have the public key pk1 corresponding to sk1, after receiving the quote and its signature sig1, the user device sends the quote and its signature sig1 to the IAS. The IAS verifies the quote's signature sig1 using the public key pk1 and returns the verification result to the user device. To prevent the verification result from being intercepted or modified, the IAS signs the verification result with its own private key to obtain the signature sig2, and sends the verification result and its signature sig2 to the user device.

[0052] After receiving the verification result, if the verification result indicates that sig1 is correct, the user device verifies hash1 in the quote against the correct hash value of the code in the TEE obtained in advance. If they are consistent, the remote attestation verifies that the correct code is running in the TEE of the model training device. At the same time, the user device can obtain the public key pk2 from the report.

[0053] In step S305, the user device generates an encryption key KeyA and asymmetrically encrypts KeyA using the public key pk2 to obtain the ciphertext KeyA. By using the public key pk2 to asymmetrically encrypt the key KeyA, the user device ensures that only the model training device TEE with the private key sk2 can decrypt the ciphertext KeyA to obtain the plaintext KeyA, ensuring that the key KeyA will not be leaked. The user device can then use the key KeyA to symmetrically encrypt the data to be processed, ensuring data security.

[0054] In step S307, the user device sends the ciphertext key to the TEE of the model training device.

[0055] In step S309: after receiving the ciphertext key, the TEE of the model training device uses the private key sk2 to decrypt the ciphertext key to obtain the key KeyA, and associates the key KeyA with the identifier of user A and stores it in the TEE.

[0056] Specifically, after receiving the ciphertext KeyA, the TEE can execute the TEE OS to obtain the pre-stored private key sk2, decrypt the ciphertext KeyA using the private key sk2, and store the plaintext KeyA in the TEE in association with the identifier of user A. By storing the key KeyA corresponding to user A in this way, the TEE can obtain the key KeyA corresponding to user A by executing the TEE OS to encrypt and decrypt user A's data.

[0057] FIG4 is a flow chart of a method for model training based on TEE in an embodiment of this specification.

[0058] As shown in FIG4 , in step S401 , the user device generates a plurality of ciphertext sample data.

[0059] The user device is, for example, the device of user A, and the ciphertext sample data can be obtained by symmetrically encrypting multiple samples using the key KeyA obtained as described above. In the case where the model to be trained is a clustering model, each sample includes feature data. For example, if the clustering model is used to cluster multiple users, the feature data includes various features of the user, such as the user's gender, age, height, weight and other user attributes. In the case where the model to be trained is, for example, a neural network model, each sample includes feature data and label data. For example, if the neural network model is used to predict the classification of the user, the feature data of the sample includes various features of the user, such as the user's gender, age, height, weight and other user attributes, and the label data of the sample includes a category identifier for classifying the user.

[0060] The user device may also generate a model training request, including the multiple ciphertext sample data in the model training request, requesting model training based on the multiple ciphertext sample data. The model training request may include the identifier of user A to indicate that the model training request is issued by user A. If multiple algorithms are loaded in the TEE, the model training request also includes information such as the identifier of the algorithm used.

[0061] In addition, the model training request may also include data such as static parameters of the model training algorithm. For example, if the algorithm is the XGB algorithm, the model training request may also include the identifier of the XGB algorithm and static parameters of the XGB algorithm (such as the number of trees and tree height parameters of the tree model). The static parameters of the XGB algorithm may be in plaintext or encrypted form.

[0062] In one embodiment, user A and user B each provide their sample data to the TEE for, for example, federated learning. In this case, the model training request may also include information such as the identifiers of the federated learning participants and the role types of each participant. Information such as the identifiers of the federated learning participants and the role types of each participant may be included in the encrypted data.

[0063] In one embodiment, the model training request may also include preset verification parameters, which may include, for example, correct algorithm parameter items, so that the TEE can verify the received algorithm parameters.

[0064] In one embodiment, the model training request also includes a hash value hash1 of a plaintext sample corresponding to each ciphertext sample, so as to verify the plaintext sample corresponding to each ciphertext sample.

[0065] In one embodiment, the model training request also includes hash values ​​hash2 corresponding to multiple ciphertext samples, which are generated based on the hash values ​​of multiple plaintext samples corresponding to the multiple ciphertext samples, so as to further verify the plaintext samples corresponding to the multiple ciphertext samples.

[0066] In step S403, the user device sends multiple ciphertext sample data to the model training device.

[0067] Specifically, the user device can send the above-mentioned model training request including multiple encrypted sample data to the outside of the TEE of the model training device.

[0068] In step S405, the model training device stores multiple ciphertext samples.

[0069] Specifically, the model training device may store the received multiple ciphertext samples in a memory outside the TEE. The model training device may also store the multiple ciphertext samples in a permanent storage medium.

[0070] When the model training device also receives the hash value hash1 of each of the above-mentioned plaintext samples (or the hash value hash2 corresponding to multiple plaintext samples), the hash value of each plaintext sample (or the hash value corresponding to multiple plaintext samples) can be stored together with multiple ciphertext samples in the memory outside the TEE.

[0071] Specifically, the model training device can sequentially store multiple ciphertext samples in the address addr1 in the memory outside the TEE, and provide the address addr1 to the TEE. The model training device can provide the address addr1 to the TEE by calling the ecall function provided by the TEE outside the TEE.

[0072] More specifically, the model training device can generate an algorithm call request based on the model training request and provide the algorithm call request to the TEE. The algorithm call request is used to call the model training algorithm in the TEE. The algorithm call request may include the memory address addr1 where the ciphertext data is stored, the algorithm identifier to be called, the algorithm parameters, etc.

[0073] In one embodiment, a thread outside the TEE can copy the algorithm call request into the TEE by calling the ecall function, thereby providing it to the TEE.

[0074] In another embodiment, a thread outside the TEE can store an algorithm call request in a shared memory outside the TEE, where the shared memory is configured for shared use by threads outside the TEE and threads inside the TEE. The threads inside the TEE can read and write the shared memory by calling the ocall function. The thread inside the TEE can read the algorithm call request stored in the shared memory by calling the ocall function and store the read algorithm call request inside the TEE, thereby providing the algorithm call request to the TEE.

[0075] After the TEE obtains the algorithm call request, as shown in FIG4 , steps S407 and S409 may be executed cyclically based on the algorithm call request to perform model training.

[0076] In step S407 , the TEE obtains several ciphertext samples from multiple ciphertext samples stored outside the TEE.

[0077] Specifically, TEE can obtain n ciphertext samples from multiple ciphertext samples, where n can be 1, or n can be a smaller integer greater than 1, such as 3, 5, etc.

[0078] TEE can obtain ciphertext samples from outside the TEE in different ways.

[0079] In one embodiment, as shown in Figure 1, the TEE may obtain a plurality of ciphertext samples from outside the TEE by executing a model training algorithm. In one embodiment, the TEE may obtain a plurality of ciphertext samples and hash values ​​hash1 of their corresponding plaintext samples or hash values ​​hash2 corresponding to the plurality of plaintext samples from outside the TEE.

[0080] Specifically, when executing the model training algorithm, TEE can switch to the outside of TEE by calling the ocall function provided by TEE, read a number of ciphertext samples from outside TEE, and store the ciphertext samples in TEE memory. In another way, TEE can obtain the address addr1 for storing multiple ciphertext samples from outside TEE as described above, directly read a number of ciphertext samples from the address addr1, and store the ciphertext samples in TEE memory. After reading a number of ciphertext samples from address addr1, TEE can store the offset address corresponding to the ciphertext samples starting from the starting address of address addr1 in TEE memory, so as to be used to read another number of ciphertext samples starting from the offset address of addr1 in the next cycle.

[0081] In another embodiment, after receiving an algorithm call request, a thread in the TEE (e.g., thread 1) executes a model training algorithm according to the algorithm call request. The algorithm calls the read interface provided by the TEE OS to read the data to be processed. In one embodiment, thread 1 can obtain the read interface according to the call and execute the read interface. In another embodiment, thread 1 can send the call request and input parameters for the read interface to thread 2 for executing the TEE OS according to the call, and thread 2 executes the read interface.

[0082] Among them, the algorithm call request includes, for example, a memory address addr1 for storing ciphertext sample data, and the input parameters to the read interface may include the memory address addr1. Figure 5 is a schematic diagram of the process of reading data through the read interface in this embodiment. As shown in Figure 5, the thread outside the TEE can store the algorithm call request including the memory address addr1 in the shared memory, and the thread inside the TEE can read the algorithm call request from the shared memory by calling the ocall function. The thread inside the TEE can obtain the memory address from the algorithm call request when executing the read interface. Afterwards, the thread inside the TEE can sequentially read a number of ciphertext sample data from the memory address addr1 according to the code of the read interface. After reading a number of ciphertext sample data, the thread inside the TEE can store the several ciphertext sample data in the TEE memory as shown in Figure 2, for model training based on the several ciphertext sample data.

[0083] In this case, by utilizing the inherent characteristics of TEE, after obtaining the memory address where the encrypted data is stored, the encrypted data can be read directly from the memory address, eliminating the need for context replacement and speeding up model training.

[0084] In step S409, the TEE decrypts the ciphertext samples to obtain the plaintext samples, updates the model parameters based on the plaintext samples, and deletes the ciphertext samples.

[0085] After obtaining several ciphertext samples within the TEE, the pre-stored key KeyA corresponding to user A can be obtained from the TEE, and KeyA can be used to decrypt each ciphertext sample to obtain several plaintext samples. As described above, the several plaintext samples are encrypted together through the MEE to obtain new ciphertext data (for example, ciphertext sample 2' in Figure 1), and the new ciphertext data is also stored in the memory within the TEE.

[0086] When several ciphertext samples are obtained through TEE OS in TEE, the multiple ciphertext samples can be decrypted by TEE OS to obtain multiple plaintext samples, and as described above, encrypted through MEE to obtain new ciphertext data (such as ciphertext sample 2' in Figure 1), and the new ciphertext data is stored in the memory within the TEE, and the address of the TEE memory storing the new ciphertext data is returned to the model training algorithm.

[0087] Afterwards, the TEE can perform model training based on the new ciphertext data. Specifically, the TEE can read the new ciphertext data, decrypt it through the MEE to obtain the plaintext samples, run the model training algorithm based on the plaintext samples, obtain updated model parameters, and store the updated model parameters as the current parameters of the model in the TEE memory.

[0088] Among them, in the case where TEE also obtains the hash value of each plaintext sample from outside TEE, after obtaining several plaintext samples, the several plaintext samples are verified respectively based on the hash value of each plaintext sample. When the verification of each plaintext sample is passed, the current parameters of the model are updated based on the several plaintext samples.

[0089] Specifically, when the model to be trained is a clustering model, the TEE, according to the model training algorithm, inputs the sample into the clustering model to obtain the clustering results of the sample, and updates the parameters of the clustering model based on the clustering results of the sample. When the model to be trained is a neural network model, the TEE, according to the model training algorithm, inputs the feature data in the sample into the neural network model to obtain the model output, and updates the model parameters based on the model output and the sample label value, so that the output of the updated model is closer to the sample label value.

[0090] The TEE may store hash values ​​hash1 of the aforementioned plaintext samples in the TEE memory. After determining that hash values ​​hash1 of multiple plaintext samples corresponding to hash value hash2 are already stored in the TEE, the TEE may verify the multiple hash1s based on the hash values ​​hash2 stored in the TEE. If the verification fails, the TEE may roll back the update of the parameters of the first model.

[0091] In one embodiment, the TEE may obtain verification parameters and model training algorithm parameters from outside the TEE as described above, and the TEE may further verify the model training algorithm parameters based on the verification parameters. For example, the verification parameters may be input parameters of the correct algorithm, and the TEE may compare the verification parameters with the actual input parameters of the algorithm. If the comparison results are consistent, the verification is determined to have passed. If the verification is determined to have passed, model training may be performed based on several plaintext samples.

[0092] After completing a model training based on several ciphertext samples, the TEE can delete several ciphertext samples in the TEE memory, such as ciphertext sample 2, as shown in Figure 1 or 2, and delete the ciphertext data generated by MEE encryption in the TEE memory (such as ciphertext sample 2') to save TEE memory and provide larger memory capacity for the next round of model training. The TEE can determine whether the loop has ended based on preset rules. If it is determined that the loop has not ended, as shown in Figure 4, steps S407 and S409 are executed again to perform the next round of model training.

[0093] In one embodiment, the TEE can determine model performance based on a test sample set and determine whether to terminate the loop based on the model performance. Similar to the model training process described above, the TEE can sequentially read several test samples from outside the TEE through streaming processing, perform multiple rounds of testing, and update the model's performance parameters after each round of testing to ultimately determine the model's performance. This streaming processing approach allows model performance testing to be performed within the TEE, even if the test sample set is large.

[0094] When TEE determines that the model training cycle is completed, it can use KeyA to encrypt the final model parameters to obtain the ciphertext model parameters, and provide the ciphertext model parameters outside the TEE to the user device.

[0095] In one embodiment, the TEE can use KeyA to encrypt the final model parameters based on the call to the write interface in the TEE OS in the model training algorithm to obtain the ciphertext model parameters, and store the ciphertext model parameters outside the TEE.

[0096] Specifically, during the execution of the model training algorithm, after obtaining the final model parameters, thread 1 in TEE executes the write interface of TEE OS according to the call to the write interface in the model training algorithm, or notifies thread 2 to execute the write interface.

[0097] FIG6 is a schematic diagram of the process of providing ciphertext model parameters to the outside of TEE through a write interface in an embodiment of this specification.

[0098] In one embodiment, the input parameters to the write interface include the above-mentioned model parameters. During the execution of the write interface, the TEE obtains the key KeyA, encrypts the model parameters using the key Key, and obtains the ciphertext model parameters. As shown by the dotted arrow in Figure 6, the ocall function is called to store the ciphertext model parameters in the shared memory, thereby providing them to the outside of the TEE.

[0099] In another embodiment, the input parameters to the write interface include the above-mentioned model parameters and the above-mentioned memory address addr1 for storing ciphertext samples. During the execution of the write interface, the TEE obtains the key KeyA, uses the key Key to encrypt the model parameters, and obtains the ciphertext model parameters. Then, as shown by the solid arrow in Figure 6, the ciphertext model parameters are directly stored in the memory address addr1, thereby providing them to the outside of the TEE.

[0100] In the above process, the algorithm within the TEE can complete complex data encryption and decryption, as well as data interaction with outside the TEE, by directly calling the read or write interface provided by the TEE OS. Algorithm developers no longer need to understand the technical details of the TEE, but only need to focus on the processing process of the algorithm itself, which greatly reduces the burden on algorithm developers.

[0101] In one embodiment, TEE OS may provide an algorithm configuration interface. When an algorithm developer loads an algorithm into TEE, he or she may provide an algorithm configuration request to TEE. The algorithm configuration request calls the configuration interface and specifies the configuration information of the algorithm through the input parameters of the configuration interface.

[0102] This configuration interface provides the following configurations for the algorithm: whether it is a service-based operator. Service-based operators are automatically started at system startup and resident in memory, suitable for real-time computing requests. Non-service-based operators are elastically launched when the scheduling engine needs them, suitable for offline computing requests; the execution environment, such as support for Python 3.7 and Java 11 execution environments; whether input and output files are cached; operator parallelism; and restrictions on files, heaps, mmaps, and stacks supported by operators. Algorithm developers can specify these specific configurations in text format (such as JSON). When the TEE OS executes this configuration interface within the TEE, it automatically sets up the complete execution environment and configures the corresponding file system configuration, effectively supporting operator development.

[0103] FIG7 is an architectural diagram of a model training device according to an embodiment of this specification. The model training device includes a trusted execution environment (TEE), wherein the TEE is loaded with a first algorithm for training a first model. The model training device is configured to execute the method shown in FIG3 or FIG4 , including:

[0104] A receiving unit 71 is configured to receive a plurality of ciphertext sample data, wherein the plurality of ciphertext sample data are respectively generated by encryption based on the same key;

[0105] A storage unit 72 is configured to store the plurality of ciphertext sample data outside the TEE;

[0106] The training unit 73 is used to enable the TEE to loop and perform the following operations: obtain some ciphertext sample data from the multiple ciphertext sample data from outside the TEE and store them in the memory within the TEE, decrypt the some ciphertext sample data to obtain some plaintext sample data, run the first algorithm based on the some plaintext sample data, update the current parameters of the first model to obtain the first parameters of the first model, store the first parameters as the current parameters of the first model, and delete the some ciphertext sample data.

[0107] The embodiments of this specification also provide a computer-readable storage medium having a computer program stored thereon. When the computer program is executed in a computer, the computer is caused to execute the method shown in FIG. 3 or FIG. 4 .

[0108] An embodiment of this specification also provides a model training device, including a memory and a processor, wherein the memory stores executable code, and when the processor executes the executable code, the method shown in Figure 3 or Figure 4 is implemented.

[0109] In the 1990s, technological improvements could be clearly distinguished as either hardware improvements (for example, improvements to circuit structures like diodes, transistors, and switches) or software improvements (improvements to process flows). However, with the advancement of technology, many process flow improvements today can now be considered direct improvements to hardware circuit structures. Designers almost always create the corresponding hardware circuit structure by programming the improved process flow into the hardware circuit. Therefore, it cannot be said that a process flow improvement cannot be implemented using hardware modules. For example, a programmable logic device (PLD), such as a field programmable gate array (FPGA), is an integrated circuit whose logical function is determined by user programming. Designers can "integrate" a digital system on a PLD by programming it themselves, without having to hire a chip manufacturer to design and manufacture a dedicated integrated circuit chip. Moreover, nowadays, instead of manually fabricating integrated circuit chips, this programming is mostly done using "logic compiler" software. This is similar to the software compiler used when developing programs. Before compilation, the original code must also be written in a specific programming language, called a hardware description language (HDL). There is not just one HDL, but many, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc. The most commonly used are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art will also understand that by simply programming the method flow in one of these hardware description languages ​​and then programming it into an integrated circuit, a hardware circuit that implements the logic method flow can be easily obtained.

[0110] The controller can be implemented in any suitable manner. For example, the controller can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320. The memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also know that in addition to implementing the controller in a purely computer-readable program code format, the controller can be implemented in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, such a controller can be considered a hardware component, and the devices included therein for implementing various functions can also be considered as structures within the hardware component. Or even, the devices for implementing various functions can be considered as both software modules that implement the method and structures within the hardware component.

[0111] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a server system. Of course, this application does not exclude that with the future development of computer technology, the computer that implements the functions of the above embodiments may be, for example, a personal computer, a laptop computer, an in-vehicle human-computer interaction device, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0112] Although one or more embodiments of this specification provide method operation steps as described in the embodiments or flow charts, more or fewer operation steps may be included based on conventional or non-creative means. The order of steps listed in the embodiments is only one way of executing the order of many steps and does not represent the only execution order. When the device or terminal product in practice is executed, it can be executed in sequence or in parallel according to the method shown in the embodiments or the drawings (for example, a parallel processor or a multi-threaded processing environment, or even a distributed data processing environment). The term "comprise", "include" or any other variant thereof is intended to cover non-exclusive inclusion, so that the process, method, product or equipment including a series of elements includes not only those elements, but also includes other elements that are not clearly listed, or also includes elements inherent to such process, method, product or equipment. In the absence of more restrictions, it is not excluded that there are other identical or equivalent elements in the process, method, product or equipment including the elements. For example, if the words first, second, etc. are used to represent the name, they do not represent any particular order.

[0113] For the convenience of description, the above devices are described in terms of functions divided into various modules. Of course, when implementing one or more of the present specifications, the functions of each module can be implemented in the same or multiple software and / or hardware, or the module that implements the same function can be implemented by a combination of multiple sub-modules or sub-units, etc. The device embodiments described above are merely schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interfaces, devices or units, which can be electrical, mechanical or other forms.

[0114] The present invention is described with reference to the flowcharts and / or block diagrams of the methods, apparatus (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as the combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device produce a device for implementing the functions specified in one or more processes in the flowchart and / or one or more blocks in the block diagram.

[0115] These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a product including an instruction device that implements the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0116] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0117] In a typical configuration, a computing device includes one or more processors (CPUs), input / output interfaces, network interfaces, and memory.

[0118] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0119] Computer-readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer-readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic disk storage, graphene storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory media such as modulated data signals and carrier waves.

[0120] Those skilled in the art will appreciate that one or more embodiments of this specification may be provided as a method, system, or computer program product. Thus, one or more embodiments of this specification may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware. Furthermore, one or more embodiments of this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0121] One or more embodiments of this specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, and the like that perform specific tasks or implement specific abstract data types. One or more embodiments of this specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communications network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0122] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between the various embodiments can be referenced across them. Each embodiment focuses on the differences from the other embodiments. In particular, since the system embodiments are generally similar to the method embodiments, their description is relatively simple. For relevant parts, reference can be made to the description of the method embodiments. Throughout this specification, reference to the terms "one embodiment," "some embodiments," "examples," "specific examples," or "some examples" means that the specific features, structures, materials, or characteristics described in conjunction with that embodiment or example are included in at least one embodiment or example of this specification. In this specification, the schematic representations of these terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. Furthermore, those skilled in the art may combine and integrate the different embodiments or examples, and features of different embodiments or examples, described in this specification, without conflict.

[0123] The foregoing description is merely an example of one or more embodiments of this specification and is not intended to limit the one or more embodiments of this specification. Those skilled in the art will appreciate that various modifications and variations of one or more embodiments of this specification are possible. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of this specification are intended to be included within the scope of the claims.

Claims

1. A model training method for privacy protection, performed by a model training device, wherein the model training device includes a trusted execution environment TEE, wherein: The TEE is loaded with a first algorithm, the first algorithm is used to perform model training on a first model, and the method includes: Receiving multiple ciphertext sample data; Storing the plurality of ciphertext sample data outside the TEE in the model training device; The TEE loop performs the following operations: obtaining some ciphertext sample data from the outside of the TEE and storing them in the memory within the TEE, decrypting the some ciphertext sample data to obtain some plaintext sample data, running the first algorithm based on the some plaintext sample data, updating the current parameters of the first model to obtain the first parameters of the first model, storing the first parameters as the current parameters of the first model, and deleting the some ciphertext sample data.

2. The method according to claim 1, further comprising: After obtaining a number of plaintext sample data, the TEE encrypts the plaintext sample data to obtain ciphertext data, stores the ciphertext data in a memory within the TEE, and deletes the ciphertext data after obtaining the first parameter.

3. The method according to claim 1, further comprising: receiving first hash values ​​of respective plaintext samples corresponding to respective ciphertext sample data, storing the first hash values ​​corresponding to respective ciphertext sample data outside the TEE, the TEE reading the first hash values ​​corresponding to the first ciphertext sample data from outside the TEE, and after obtaining the first plaintext sample data, verifying the first plaintext sample data based on the first hash values ​​corresponding to the first ciphertext sample data, The TEE updating the current parameters of the first model based on the first plaintext sample includes: the TEE updating the current parameters of the first model based on the first plaintext sample when the first plaintext sample data is verified successfully.

4. The method according to claim 3, further comprising: receiving second hash values ​​corresponding to a number of second ciphertext sample data, where the second hash values ​​are generated based on respective hash values ​​of a number of second plaintext sample data corresponding to the number of second ciphertext sample data, and storing the second hash values ​​outside the TEE; The TEE reads the second hash value from outside the TEE, stores the first hash value of each second ciphertext sample, and verifies the first hash values ​​of the plurality of second ciphertext samples based on the second hash value; If the verification fails, the update of the parameters of the first model is rolled back.

5. According to the method of claim 1, the TEE is also loaded with a TEE operating system, the TEE operating system provides a read interface, the first algorithm includes a call to the read interface, and the method further includes: In response to receiving a plurality of ciphertext sample data, generating an algorithm call request, and providing the algorithm call request to the TEE for calling the first algorithm; The TEE reads the first ciphertext sample data and decrypts the first ciphertext sample data, including: the TEE responds to the algorithm call request, reads the first ciphertext sample data according to the call of the read interface in the first algorithm, and decrypts the first ciphertext sample data; The method also includes: after obtaining the first plaintext sample data, the TEE returns the first plaintext sample data to the first algorithm according to the read interface.

6. According to the method of claim 5, the TEE operating system also provides a write interface, and the method further includes: When the TEE determines that the loop is completed, the TEE encrypts the current parameters of the first model according to the call to the write interface in the first algorithm, obtains the ciphertext model parameters, and stores the ciphertext model parameters outside the TEE in the model training device.

7. The method according to claim 5, wherein the ciphertext sample data is generated by symmetric encryption using a first key, and the method further comprises: Receiving a ciphertext first key sent by a user device, where the ciphertext first key is generated by asymmetrically encrypting the first key using a public key provided by the TEE; Providing the ciphertext first key to the TEE, wherein the public key and the private key corresponding to the public key are pre-generated by the TEE operating system; The TEE executes the TEE operating system and uses the private key to decrypt the ciphertext first key to obtain the first key, and stores the first key in association with the user identifier corresponding to the user device.

8. The method according to claim 7, wherein receiving a plurality of ciphertext sample data comprises: A plurality of ciphertext sample data and their corresponding user identifiers are received, the method further comprising: providing the user identifier in association with the plurality of ciphertext sample data to the TEE, the TEE decrypting the first ciphertext sample data comprising: reading the first key based on the user identifier, and using the first key to decrypt the first ciphertext sample data.

9. According to the method of claim 5, the receiving a plurality of ciphertext sample data comprises: Receiving multiple ciphertext sample data and their corresponding verification parameters and algorithm parameters, providing the verification parameters and algorithm parameters to the TEE, and the TEE returning the first plaintext sample data to the first algorithm includes: after obtaining the first plaintext sample data, the TEE verifies the algorithm parameters based on the verification parameters, and returns the first plaintext sample data to the first algorithm if the verification passes.

10. The method according to claim 1, wherein the TEE operating system further comprises a configuration interface, and the method further comprises: Obtaining an algorithm configuration request, the algorithm configuration request calling the configuration interface, including configuration information corresponding to the first algorithm, for configuring the first algorithm; providing the algorithm configuration request to the TEE; The TEE configures the first algorithm based on the configuration information according to the algorithm configuration request.

11. According to the method of claim 10, the configuration information includes at least one of the following configuration information: configuration information for setting the service operator; execution environment information; cache configuration information for input and output files; parallelism; supported files, and configuration information corresponding to the heap, mmap and stack.

12. According to the method of claim 6, storing the plurality of ciphertext sample data outside the TEE comprises: Storing the plurality of ciphertext sample data to a first address in a memory outside the TEE; The method also includes providing the first address into the TEE.

13. According to the method of claim 12, storing the ciphertext model parameters outside the TEE in the model training device includes storing the ciphertext model parameters to the first address.

14. The method according to claim 12, wherein the TEE stores an offset address in the first address, and the TEE reads a number of ciphertext sample data from outside the TEE, comprising: The TEE reads a number of ciphertext sample data from outside the TEE based on the offset address and updates the offset address.

15. A model training device, comprising a trusted execution environment TEE, wherein: The TEE is loaded with a first algorithm, the first algorithm is used to perform model training on a first model, and the model training device includes: A receiving unit, used for receiving a plurality of ciphertext sample data; A storage unit, used to store the plurality of ciphertext sample data outside the TEE; A training unit is used to enable the TEE to loop and perform the following operations: obtain some ciphertext sample data from the outside of the TEE and store them in the memory within the TEE, decrypt the some ciphertext sample data to obtain some plaintext sample data, run the first algorithm based on the some plaintext sample data, update the current parameters of the first model to obtain the first parameters of the first model, store the first parameters as the current parameters of the first model, and delete the some ciphertext sample data.

16. A model training device, comprising a memory and a processor, wherein the memory stores executable code, and when the processor executes the executable code, the method described in any one of claims 1 to 14 is implemented.

Images