Privacy Protection Method and System for Data Utilization Based on Virtual Machine Trusted Execution Environment
By building and managing container images of static executable applications in a virtual machine trusted execution environment, using convisors to manage the application lifecycle and leveraging VM TEE hardware I/O capabilities, the problem of data leakage in VM TEE is solved, the security of multi-party data utilization is improved, and application development is simplified.
Patent Information
- Application Number
- CN202510594822.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-05-09
- Publication Date
- 2026-11-10
AI Technical Summary
Existing technologies based on Virtual Machine Trusted Execution Environment (VM TEE) for multi-party data exploitation have data leakage problems, especially in data annotation and medical data referral scenarios. The isolation methods of enclave and guest OS cannot effectively prevent information leakage, and container solutions have attack paths in multi-party data exploitation scenarios.
A static executable application container image is built using pre-defined image technology, and the application container is launched in the virtual machine trusted execution environment through the container runtime run command. A single hypervisor manages the application lifecycle, restricts the user's interaction with the VM TEE interface, and directly utilizes the hardware I/O functions of the VM TEE operating system to avoid hardware I/O being executed outside the enclave.
This enables entities other than data processing programs to access data within the VM TEE, reducing application development complexity, lowering the risk of information leakage, and improving the security of multi-party data utilization.
Smart Images

Figure CN123069408A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of data security technology, and in particular to a method and system for data utilization and privacy protection based on a virtual machine trusted execution environment. Background Technology
[0002] With the widespread application of artificial intelligence technology, data has risen to become a new means of production, and at the same time, people's demand for data privacy protection is increasing.
[0003] Privacy-preserving computing has emerged as a technological solution to address these needs, achieving data usability without visibility. This includes solutions based on Trusted Execution Environments (TEEs), with virtual machine (VM) type TEEs being the primary technological approach. Examples include AMD / Hygon's encrypted virtual machine solution, Intel's TDX (trusted domain extension) solution, and ARM's Realm solution, which is also based on virtual machines. VM-type TEEs are mainly used in cloud computing scenarios to protect cloud tenants' data from attacks by cloud service providers. However, direct use for multi-party data exploitation poses a data leakage problem, as the VM owner could potentially view the data processed within it.
[0004] The academic community has also recognized that VM-type TEEs isolate virtual machines, not applications. Therefore, academic research primarily focuses on designing solutions to prevent interference from the guest operating system (OS) to applications. Most solutions aim to isolate the guest OS from the application, preventing the guest OS from accessing the application. Specifically, in terms of development models, applications are divided into non-security-sensitive and security-sensitive parts, with the security-sensitive parts running within an enclave. The key is to design various methods to prevent the guest OS from accessing the enclave. This application development model is essentially the same as that of ARM TrustZone and Intel SGX. This approach makes application development complex and increases the cost of porting existing applications. Furthermore, due to the isolation between the enclave and the guest OS, the enclave's ability to handle system calls is inevitably limited, forcing some functions to rely on external systems, which can also lead to information leakage. For example, in data annotation and medical data referral scenarios, data needs to be displayed for human viewing. This involves hardware I / O that needs to be performed outside the enclave, which is untrusted and could intercept data, resulting in information leakage. The approach of isolating guest OS and enclave cannot solve data utilization scenarios such as data annotation or medical data referral.
[0005] From an industry perspective, many cloud vendors use VM-type TEEs for multi-party data exploitation. Currently, this is primarily achieved by deploying container runtimes and container applications within the VM TEE. However, current container solutions still have some issues when used in multi-party data exploitation scenarios. Although the deployment principle of containers is one container, one application, containers do not inherently guarantee this. Numerous attack paths still exist in multi-party data exploitation scenarios. Summary of the Invention
[0006] This invention provides a data utilization privacy protection method and system based on a virtual machine trusted execution environment, which solves the data privacy protection problem when processing multi-party data within a VM-type TEE in the prior art, and ensures that no entity other than the data processing program can access the processed data, thereby preventing data leakage.
[0007] In a first aspect, the present invention provides a data utilization privacy protection method based on a virtual machine trusted execution environment, comprising: Develop the target application in a complete development environment and compile it into a statically executable application. A container image of the static executable application is constructed using a pre-defined image technology. The application container for the static executable application is built and started using the run command of the container runtime.
[0008] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, which constructs a container image of the static executable application using a preset image technology, including: Build a container image of a single static executable application using a Scratch image; Alternatively, multi-stage container development techniques can be used to develop container images for multi-stage static executable applications.
[0009] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, which utilizes the container runtime run command to build and start the application container of the static executable application, including: The system consists of a host and virtual machines. The host monitors and manages the virtual machines through a hypervisor. The host includes the host machine runtime software, and the virtual machines include the application convisor within the virtual machines and containers that run various applications. The host container runtime software includes containerd and kata-runtime. Containerd chooses kata-runtime as one of its supported container runtimes, both of which run within the host. The `run` command is executed on the host machine, and kata-runtime calls the virtual machine management tools on the host machine to construct and start the virtual machine. After the virtual machine starts, the convisor located in the initial root file system is launched as the initial process. The convisor performs preset management of the container lifecycle according to the host container running instructions. The preset management includes building the container, running the container, and shutting down the container.
[0010] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, which uses the docker run command to build and start the application container of the static executable application, and further includes: The system is defined to include virtual machines, which use a container-optimized operating system (COS) that only supports container applications. The virtual machines include a container runtime (convisor) within the virtual machine and containers that run various applications. When you execute the `docker run` command in a virtual machine, the container runtime convisor manages the container's lifecycle according to the user's instructions.
[0011] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, wherein the convisor is a single management program that does not support the cp command, any volume loading operation, or the exec command; The convisor supports traditional container runtime functions, WASM runtime functions, and process-based virtual machine runtime functions.
[0012] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, wherein the virtual machine supports direct connection with preset I / O peripherals.
[0013] According to the present invention, a data utilization privacy protection method based on a virtual machine trusted execution environment is provided, wherein the kernel of the virtual machine supports remote proof, the correctness of the remote proof is verified by a verifier as a stakeholder, and the functionality of the virtual machine system is confirmed to meet expectations by combining the operating system of the virtual machine and the software code of the convisor.
[0014] Secondly, the present invention also provides a data utilization privacy protection system based on a virtual machine trusted execution environment, comprising: Develop a compilation module to develop the target application in a complete development environment and compile the target application into a statically executable application. A build module is used to build a container image of the static executable application using a preset image technology; The execution module is used to build and start the application container of the static executable application using the run command of the container runtime.
[0015] Thirdly, the present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the program, implements the data utilization privacy protection method based on a virtual machine trusted execution environment as described above.
[0016] Fourthly, the present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the data utilization privacy protection method based on a virtual machine trusted execution environment as described above.
[0017] The data utilization privacy protection method and system based on the virtual machine trusted execution environment provided by this invention does not follow the research route of dividing the application into data-sensitive and non-sensitive parts and isolating the guest OS and sensitive parts. Instead, based on the characteristics of TEE having physical machine abstraction, it takes the route of reducing the user and TEE interaction interface to a minimum, thereby preventing malicious users from launching attacks by using the various functions of the host, VM TEE, etc., while maintaining the traditional development mode of applications under physical machine conditions. Attached Figure Description
[0018] To more clearly illustrate the technical solutions in this invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.
[0019] Figure 1 This is a flowchart illustrating the privacy protection method for data utilization based on a virtual machine trusted execution environment provided by the present invention. Figure 2 This is a system structure diagram of the first implementation method provided by the present invention; Figure 3 This is a system structure diagram of the second implementation method provided by the present invention; Figure 4 This is a schematic diagram of the data utilization privacy protection system based on a virtual machine trusted execution environment provided by the present invention; Figure 5 This is a schematic diagram of the structure of the electronic device provided by the present invention. Detailed Implementation
[0020] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.
[0021] To address the problems existing in current technologies, this invention aims to protect data privacy and prevent data leakage during multi-party data utilization within a VM TEE. Threats can be categorized into internal and external threats to the VM TEE. External threats are primarily addressed through virtual machine security measures. VM TEEs require the use of virtual machines with TEE characteristics, such as AMD's SEV technology, Intel's TDX technology, and ARM's REALM technology. These technologies are designed to block various threats from the host machine to protect information within the VM TEE. To address internal threats, our approach primarily involves isolating various applications to prevent attacks between them. This invention mainly solves the problems of internal threats and information leakage caused by hardware I / O system calls executed outside the enclave. The proposed solution can be applied to scenarios such as data annotation and medical data referral.
[0022] Figure 1 This is a flowchart illustrating a privacy protection method for data utilization based on a virtual machine trusted execution environment provided in an embodiment of the present invention, as shown below. Figure 1 As shown, it includes: Step 100: Develop the target application in a complete development environment and compile the target application into a statically executable application; Step 200: Construct a container image of the static executable application using a preset image technology; Step 300: Use the container runtime run command to build and start the application container of the static executable application.
[0023] It is understandable that, in addressing threats within the VM TEE, this embodiment of the invention does not employ a technique that isolates the guest OS and applications. To prevent attacks on applications from the guest OS, our main idea is to run only a single hypervisor (convisor) within the VM TEE. This hypervisor has a relatively singular function, managing only the lifecycle of each application. Furthermore, this function is measurable and remotely verifiable; any stakeholder can use remote verification and source code analysis to confirm that the VM TEE system, including its firmware, OS, and convisor, functions as expected. To achieve this, running only a single hypervisor (convisor) within the VM TEE can utilize Kata's agent technology, Google's container-optimized OS technology, and other similar technologies.
[0024] Application isolation techniques within a TEE virtual machine can employ classic isolation methods, including traditional container-based technologies, language virtual machine technologies, or process-based virtual machine technologies, such as IBM's Nabla technology. However, modifications are necessary. For instance, the container technology itself needs to be modified to ensure that only one application can run within a container at a time. Measures include preventing files from being copied or mounted from outside the container to prevent external programs from entering, and removing the `exec` function to prevent multiple applications from running simultaneously within the container.
[0025] To prevent information leakage caused by hardware I / O system calls executing outside the enclave, we did not adopt the secure but limited enclave constructed by academia. Instead, we allowed applications to fully utilize the VM TEE's OS kernel functionality; that is, the hardware I / O system calls required by the application were implemented normally using the VM TEE operating system's capabilities. Since the VM TEE operating system's hardware I / O operations are ultimately implemented through the host, to prevent the host-side hypervisor or applications from stealing data through hardware I / O, this embodiment directly connects hardware I / O such as the GPU to the VM TEE, eliminating the need for host intervention.
[0026] Specifically, the general process of a user running a container application using the system of this embodiment of the invention is as follows: First, users develop applications in a complete development environment and compile them into a statically executable application, myapp. Build a single-application myapp container image from a scratch image or develop a myapp container image using multi-stage container development techniques; Users can use the container runtime run command, such as docker run, kubectl run, or kataruntime run. The following uses docker run as an example to illustrate how to build and start the myapp application container.
[0027] In one embodiment, the first implementation is as follows: Figure 2 As shown, this is a technical solution based on Kata containers. The entire system consists of a host, container runtime software within the host, virtual machines, a convisor within the virtual machine responsible for managing application isolation, and various containers running applications.
[0028] Assume that the container runtime software running on the host is containerd and kata-runtime, and containerd selects kata-runtime as one of its supported container runtimes. Both run within the host. Kata-runtime calls the host system's virtual machine management tools to construct lightweight virtual machines. The virtual machine's startup meets the requirements of trusted boot and can provide remote authentication to prove the virtual machine system's state, including the virtual machine's OS, firmware, and the state of the initial root file system. This virtual machine is isolated from other virtual machines constructed on the host and from the host itself. For example, virtual machines supporting AMD SEV technology, Hygon CSV technology, Intel TDX technology, or ARM Realm technology can be selected.
[0029] After the virtual machine starts, the convisor, located in the initial root file system, starts as the init process. Its role is equivalent to the agent in the Kata system; its function is to manage the lifecycle of containers according to the instructions given during container runtime on the host machine, including building, running, and shutting down containers. The main difference between the convisor and the Kata system's agent is that the convisor does not support the `cp` command and does not support any volume mounting operations to prevent the addition of new applications to containers. It also does not support the `exec` command to prevent applications from running in parallel within containers. Furthermore, when a new attack path is discovered, the convisor's functionality can be modified to restrict that attack path. In addition to supporting traditional container runtime functions, the convisor also supports Wasm runtime functions and process-based virtual machine runtime functions.
[0030] The virtual machine kernel supports remote proofs. Verifiers, acting as stakeholders, first verify the correctness of the remote proof, and then, in conjunction with the virtual machine's OS and convisor software code, confirm that the virtual machine system's functionality meets expectations. This mechanism ensures that the commands a user can execute on the VM TEE are a limited whitelist; all other commands are rejected, thus reducing the user's interaction with the VM TEE.
[0031] A VM TEE can run multiple container applications, but each container can only run a single application. There are many ways to ensure that a container image contains only a single application, such as building a single-application container from a scratch image; or using multi-stage container image building techniques. In the Kata system, container integrity can be achieved by name and signature verification, with the signature verification function performed by the convisor.
[0032] Since both the Wasm language virtual machine and the process-based virtual machine are designed for single-application tasks, there is no concern about attacks between applications within the Wasm virtual machine and the process-based virtual machine. The only requirement is to integrate both the Wasm runtime and the process-based virtual machine runtime into the convisor for management.
[0033] Because the convisor does not support the `cp` command or volume mounting, only `myapp` can run inside the container. Furthermore, it does not support the `exec` command, so users can only start the application using `docker run`. Users cannot launch attacks against container applications from the host machine using `docker` or `k8s` commands. Since the VM TEE's external interface is only the convisor, users also cannot launch attacks against container applications from within the VM TEE. However, because container images can utilize the rich functionality provided by the VM TEE kernel, their system calls can be implemented by the VM TEE. This system can directly run traditional applications, greatly reducing the difficulty of application development.
[0034] To prevent information leakage caused by hardware I / O system calls being executed outside the enclave, this embodiment allows applications to fully utilize the VM TEE's OS kernel functionality. That is, the hardware I / O system calls required by the application are implemented using the VM TEE operating system's capabilities. Since the VM TEE operating system's hardware I / O operations are ultimately implemented through the host, to prevent the host-side hypervisor or applications from stealing data via hardware I / O, we directly connect I / O peripherals such as the GPU to the VM TEE, eliminating the need for host intervention.
[0035] In one embodiment, the second implementation is as follows: Figure 2 As shown, drawing inspiration from Google's container-optimized OS, a similar COS (Container Optimized Operation System) was developed to serve as the OS for VMTEE. Compared to a regular OS, this COS has the following characteristics: (1) Does not include a package manager; (2) Does not support the execution of non-containerized applications; (3) The OS kernel is locked, so third-party kernel modules or drivers cannot be installed.
[0036] The container runtime software is called convisor. Compared to standard container runtime software, this runtime software does not support file copying, volume mounting, or exec functionality. Added functionality is the verification of container image signatures to prove container integrity. It also supports predefined language virtual machine features, such as the wasm runtime and process-oriented virtual machine runtime features.
[0037] Multiple containerized applications can run within a VM TEE, but each container can only run a single application. There are many ways to ensure that a container contains only a single application, such as building a single-application container from a scratch image; or using multi-stage container image building techniques. Container images need to be signed to facilitate verification of container integrity and to allow stakeholders to verify the container's functionality, ensuring that its performance meets expectations.
[0038] Because the convisor does not support the `cp` command or volume mounting, only `myapp` can run inside the container. Furthermore, it does not support the `exec` command, so users can only start the application using `docker run`. Since COS cannot run non-container applications, users cannot launch attacks by running other applications within a VM TEE.
[0039] The system can run traditional applications directly, which greatly reduces the difficulty of application development.
[0040] To prevent information leakage caused by hardware I / O system calls executing outside the enclave, this embodiment does not use the secure but limited enclave constructed by academia. Instead, it allows applications to fully utilize the VM TEE's OS kernel functionality; that is, the hardware I / O system calls required by the application are implemented normally using the VM TEE operating system's capabilities. Since the VM TEE operating system's hardware I / O operations are ultimately implemented through the host, to prevent the host-side hypervisor or applications from stealing data through hardware I / O, we directly connect I / O peripherals such as the GPU to the VM TEE, eliminating the need for host intervention.
[0041] Based on the above embodiments, other implementation methods that meet the requirements can also be proposed, which will not be elaborated here.
[0042] In summary, the first implementation requires executing `docker run` on the host machine, while the second implementation allows you to execute `docker run` directly within the VM tee. The second implementation is more convenient, especially in cloud deployments, as users only need to rent a VM tee to solve all the problems.
[0043] The following describes the data utilization privacy protection system based on the virtual machine trusted execution environment provided by the present invention. The data utilization privacy protection system based on the virtual machine trusted execution environment described below can be referred to in correspondence with the data utilization privacy protection method based on the virtual machine trusted execution environment described above.
[0044] Figure 4 This is a schematic diagram of the data utilization privacy protection system based on a virtual machine trusted execution environment provided in an embodiment of the present invention, such as... Figure 4 As shown, it includes: a development and compilation module 41, a build module 42, and an execution module 43, wherein: The development and compilation module 41 is used to develop the target application in a complete development environment and compile the target application into a static executable application; the build module 42 is used to build a container image of the static executable application using a preset image technology; and the execution module 43 is used to build and start the application container of the static executable application using the docker run command.
[0045] Figure 5 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 5 As shown, the electronic device may include a processor 510, a communications interface 520, a memory 530, and a communication bus 540, wherein the processor 510, communications interface 520, and memory 530 communicate with each other via the communication bus 540. The processor 510 can call logical instructions in the memory 530 to execute a data utilization privacy protection method based on a virtual machine trusted execution environment. This method includes: developing the target application in a complete development environment; compiling the target application into a static executable application; constructing a container image of the static executable application using a preset image technology; and using the `docker run` command to build and start the application container of the static executable application.
[0046] Furthermore, the logical instructions in the aforementioned memory 530 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.
[0047] On the other hand, the present invention also provides a non-transitory computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements a data utilization privacy protection method based on a virtual machine trusted execution environment provided by the above methods. The method includes: developing a target application in a complete development environment; compiling the target application into a static executable application; constructing a container image of the static executable application using a preset image technology; and constructing and starting the application container of the static executable application using the dockerrun command.
[0048] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.
[0049] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.
[0050] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.
Claims
1. A privacy protection method for data utilization based on a virtual machine trusted execution environment, characterized in that, include: Develop the target application in a complete development environment and compile it into a statically executable application. A container image of the static executable application is constructed using a pre-defined image technology. The application container for the static executable application is built and started using the run command of the container runtime.
2. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 1, characterized in that, The container image of the static executable application is constructed using a pre-defined image technology, including: Build a container image of a single static executable application using a Scratch image; Alternatively, multi-stage container development techniques can be used to develop container images for multi-stage static executable applications.
3. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 1, characterized in that, The application container for the static executable application is built and started using the `run` command of the container runtime, including: The system consists of a host and virtual machines. The host monitors and manages the virtual machines through a hypervisor. The host includes the host machine runtime software, and the virtual machines include the application convisor within the virtual machines and containers that run various applications. The host container runtime software includes containerd and kata-runtime. Containerd chooses kata-runtime as one of its supported container runtimes, both of which run within the host. The `run` command is executed on the host machine, and kata-runtime calls the virtual machine management tools on the host machine to construct and start the virtual machine. After the virtual machine starts, the convisor located in the initial root file system is launched as the initial process. The convisor performs preset management of the container lifecycle according to the host container running instructions. The preset management includes building the container, running the container, and shutting down the container.
4. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 1, characterized in that, The application container for building and starting the statically executable application using the `docker run` command also includes: The system is defined to include virtual machines, which use a container-optimized operating system (COS) that only supports container applications. The virtual machines include a virtual machine container runtime convisor and containers that run various applications. When you execute the `docker run` command in a virtual machine, the container runtime convisor manages the container's lifecycle according to the instructions.
5. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 3 or 4, characterized in that, The convisor is a single management program and does not support the cp command, any volume loading operations, or the exec command. The convisor supports traditional container runtime functions, WASM runtime functions, and process-based virtual machine runtime functions.
6. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 1, characterized in that, The virtual machine supports direct connection to preset I / O peripherals.
7. The data utilization privacy protection method based on a virtual machine trusted execution environment according to claim 1, characterized in that, The kernel of the virtual machine supports remote proof, and the correctness of the remote proof is verified by a verifier who is a stakeholder. The virtual machine's operating system and the convisor's software code are combined to confirm that the virtual machine system's functionality meets expectations.
8. A data utilization privacy protection system based on a virtual machine trusted execution environment, characterized in that, include: Develop a compilation module to develop the target application in a complete development environment and compile the target application into a statically executable application. A build module is used to build a container image of the static executable application using a preset image technology; The execution module is used to build and start the application container of the static executable application using the run command of the container runtime.
9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the data utilization privacy protection method based on a virtual machine trusted execution environment as described in any one of claims 1 to 7.
10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the data utilization privacy protection method based on a virtual machine trusted execution environment as described in any one of claims 1 to 7.
