Multi-party collaborative computation method and system based on confidential container and additive secret sharing

Abstract

The application discloses a kind of multi-party collaborative computing method and system based on confidential container and additive secret sharing, the method can be realized in HLO computing graph hierarchy Decoupling between ciphertext calculation logic and business code, so that without modifying original business code and without knowing new syntax logic, visibility determination can be completed by programmer without cryptography background, i.e. code with privacy calculation semantics can be realized.And based on the idea of combining multi-point confidential container and additive secret sharing, using the feature that plaintext can be fragmented in any number by additive secret sharing, any number of data parties can participate in the same computing task, all HLO operators can be adapted to ciphertext, support arbitrary HLO ciphertext calculation, avoid complex cryptography protocol involvement, and the performance loss caused by encryption operation is very low.

Description

Technical Field

[0001] This invention relates to the field of privacy-preserving computing technology for multi-party collaboration, and in particular, to a multi-party collaborative computing method and system, electronic device, and computer-readable storage medium based on confidential containers and additive secret sharing. Background Technology

[0002] In privacy-preserving computation scenarios based on cryptographic algorithms (such as federated learning and multi-party secure computation), the following two problems have long existed: 1) Programmers who understand the business logic do not understand the underlying cryptographic and other security technologies, while cryptographic researchers who understand security technologies do not understand the upper-level business logic. There is a gap between the two, making it difficult for traditional software developers to independently code code that can securely call multi-party data; 2) The expressive power of cryptographic low-level computation is limited. For example, it can only perform limited operations such as ciphertext multiplication and addition. For more complex operations, researchers who are proficient in cryptography usually need to perform low-level computational composition or design custom cryptographic primitives. Therefore, existing privacy-preserving computation software based on cryptographic algorithms typically includes several pre-defined multi-party collaborative computation algorithms (such as federated gradient boosting trees, privacy set intersection, and anonymous queries). The functions of these pre-defined algorithms are fixed; only the number of participants (usually limited to two parties) and the specific data used in the computation (i.e., input data) are configurable. This limits their ability to handle only common, pre-defined tasks (such as federated modeling, privacy set intersection, and anonymous queries) or requires custom development by security software vendors. This severely restricts the scalability of cryptographic federated computation products. For example, if a custom task requires a novel machine learning model that is not included in the privacy-preserving computation software, the relevant software vendor must upgrade the product, rather than quickly adding it themselves.

[0003] In addition, some existing research aims to lower the barrier for ordinary software developers. It uses specific source code (which may contain custom syntax such as pint) and a corresponding compiler to perform the conversion. It then completes multi-party collaborative computation tasks through secure collaborative computation and encrypted transmission between interpreters of different participants (this part usually relies on several or dozens of mature cryptographic operators). The general development process includes: first, writing business code with encrypted semantics based on the plaintext business logic and the corresponding encrypted development framework (e.g., its keywords, decoration methods, etc.); then, installing the necessary encrypted compiler and interpreter environment on the computing devices of each executor; finally, after the aforementioned code is written, distributing it to each party's device. Each party can verify the source code to confirm that the security meets its own requirements. After confirmation, each party provides startup parameters (usually requiring the participant number and its own input data, such as --party-id=1, --input-file=test1.csv, etc.), and executes the above code based on the compiler and interpreter tools to finally obtain the joint computation result. For example, Microsoft's paper "EzPC: Programmable and efficient secure two-party computation for machine learning" defines a high-level language with privacy semantics and describes how to map high-level programs to different secure backends (i.e. specific cryptographic algorithms for multi-party computation, such as obfuscated circuits, secret sharing, etc.) through a compiler to support joint two-party computation. However, these studies all require explicitly annotating the visibility of data using specific syntax or decorators during the initial writing of the original business code. This forces programmers writing the business code to learn entirely new coding standards, resulting in extremely high learning and migration costs. Moreover, the supported data sources are limited. Since it involves the translation of general computations, and the main cryptographic algorithms can only support two parties, existing solutions cannot support three or more data sources participating in multi-party collaborative computation tasks. In addition, the adoption of new coding standards means that all algorithms must be rewritten. For example, Microsoft's paper requires all algorithms to be rewritten in DSL language, and mature computing libraries (such as NumPy libraries, machine learning libraries, etc.) cannot be used directly, which greatly limits the expressive power. Furthermore, since the use of cryptographic schemes involves a lot of communication negotiation, there is usually a performance degradation of several orders of magnitude compared to plaintext computation. For more complex operations (such as calculating trigonometric functions, matrix inversion, etc.), the performance degradation is greater because polynomial fitting methods are needed to reduce errors.

[0004] Therefore, how to implement a programmable mechanism in privacy computing products, allowing software developers without a cryptographic background to complete new multi-party collaborative computing logic through their own coding while ensuring the privacy of data from all parties, has become a key issue that urgently needs to be addressed in privacy-preserving computing scenarios. Summary of the Invention

[0005] This invention provides a multi-party collaborative computing method and system, electronic device, and computer-readable storage medium based on confidential containers and additive secret sharing. It allows software developers without cryptographic backgrounds to complete new multi-party collaborative computing logic through self-coding, while ensuring the privacy of data from all parties. It can support any number of data parties to participate in the same computing task, support arbitrary HLO ciphertext computing, and reduce the performance loss caused by encryption operations.

[0006] According to one aspect of the present invention, a multi-party collaborative computing method based on confidential containers and additive secret sharing is provided, comprising the following: Based on the business situation, the original business code is written and distributed to each participant. Each participant compiles the original business code into an HLO computation graph. Configure visibility rules and visibility inference mechanisms, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanisms, and distribute them to all participants; Each participant binds the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file, generating the CCHLO computation graph; Each participant uses confidential containers and additive secret sharing to perform multi-party collaborative computation based on the CCHLO computation graph, and obtains joint computation results.

[0007] Furthermore, the process of generating visibility profiles for all nodes in the HLO computation graph based on configured visibility rules and visibility inference mechanisms includes the following: Traverse the HLO computation graph, identify all sets of start nodes with an in-degree of zero, and subdivide the set of start nodes into three subsets based on operator semantics: parameter node set, constant node set, and random operator set. Configure the visibility state of each subset; wherein, the visibility state of all nodes in the same subset is the same; Based on the configured visibility inference mechanism and the visibility state of the node itself, the visibility state of all intermediate nodes is derived. Configure the visibility state of the final node in the HLO computation graph to obtain the visibility configuration file for all nodes.

[0008] Furthermore, the visibility inference mechanism includes: in multivariate operations, the result obtained after calculating the data in the secret state and the data in any state is the secret state; in unary operations, the visibility state of the result is consistent with the visibility state of the input; and the result of constant operations is the public state.

[0009] Furthermore, in the process of multi-party collaborative computation based on the CCHLO computation graph, for each node in the CCHLO computation graph, if the node is a start node, the operator is executed only based on the node's own visibility state; if the node is an intermediate node or a final node, the operator is executed based on the visibility state of all in-degree nodes and the node's own visibility state.

[0010] Furthermore, for an input node in the CCHLO computation graph, if the visibility state of the input node is configured as secret, then the number of participants corresponding to that input node is determined by the number of participants. n Randomly generated in a local rich computing environment n -1 data and calculate , d This indicates the input data, and based on the numbers of the other participants, the corresponding... The value is sent to the corresponding participant, and each participant responds according to the received value. The value is executed by the operator; if the visibility state of the input node is configured to public, then the participant corresponding to the input node directly submits the input data. d Send to a specific participant, who then executes the operator, where the specific participant can be any participant.

[0011] Furthermore, for the constant node set and random operator set in the CCHLO computation graph, the operators are executed directly by a specific participant in the local rich computing environment, where the specific participant can be any participant.

[0012] Furthermore, for intermediate nodes in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, then the specific participant performs plaintext computation in the local rich computing environment. If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is secret, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. A specific participant will collect all in-degree node data. Send to a local confidential container environment to execute the operator Then, calculate Then The data is sent from the confidential container environment to the rich computing environment, while other participants obtain it directly from their own confidential container environment. ;in, k This indicates the in-degree of the intermediate node. n Indicates the number of shards in the encrypted secret sharing, subscript i Indicates the first i Slice addition sharing value; If at least one in-degree node has a secret visibility state, and the node itself also has a secret visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. , Indicates the first t The first input value i The secret value of addition is shared in slices. , Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculations yielded Then calculate Then Send from a confidential container environment to a specific participant In a rich computing environment, the remaining participants ( Obtained from our confidential container environment ; If at least one in-degree node has a secret visibility state and the node itself has a public visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculation Obtain plaintext data Then calculate Finally z Send from a confidential container environment to a specific participant In a rich computing environment.

[0013] Furthermore, for the final node in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, then the specific participant performs plaintext computation in the local rich computing environment. If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is private, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. A specific participant will collect all in-degree node data. Send to a local confidential container environment to perform operator computation: , f Describe the operators, and then calculate them separately. Then From a confidential container environment, data is sent to a rich computing environment of a specific participant. The specific participant then assigns the corresponding data based on its participant ID. Send to the specified visible participants, who then obtain the information from their own confidential container environment. And compute in a local rich computing environment ; If at least one in-degree node has a secret visibility state and the node itself has a public visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculation Obtain plaintext data Then calculate Finallyz Send from a confidential container environment to a specific participant In rich computing environments, specific stakeholders Will z Send to the other participants ( ); If at least one in-degree node has a visibility state of secret, and the node itself has a visibility state of private, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. , Indicates the first t The first input value i The secret value of addition is shared. , Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculations yielded Then calculate Then Sending from a confidential container environment to a rich computing environment by specific stakeholders Will Send to the specified visible participants Specify visible participants to obtain from their own confidential container environment And compute in a rich computing environment .

[0014] In addition, the present invention also provides a multi-party collaborative computing system based on confidential containers and additive secret sharing, comprising: The HLO computation graph generation module is used to write original business code based on business conditions and distribute it to each participant. Each participant compiles the original business code into an HLO computation graph. The visibility file configuration module is used to configure visibility rules and visibility inference mechanisms, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanisms, and distribute them to each participant; The CCHLO computation graph generation module is used by each participant to bind the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file, and generate the CCHLO computation graph. The multi-party collaborative computing module is used by participating parties to share confidential containers and additive secrets, and to perform multi-party collaborative computing based on the CCHLO computing graph to obtain joint computing results.

[0015] In addition, the present invention also provides an electronic device, including a processor and a memory, wherein the memory stores a computer program, and the processor executes the steps of the method described above by calling the computer program stored in the memory.

[0016] In addition, the present invention provides a computer-readable storage medium for storing a computer program for multi-party collaborative computation based on a confidential container and additive secret sharing, wherein the computer program executes the steps of the method described above when running on a computer.

[0017] The present invention has the following beneficial effects: This invention presents a multi-party collaborative computation method based on confidential containers and additive secret sharing. Through configured visibility rules and a visibility inference mechanism, it configures the visibility of all nodes in the HLO computation graph, generating a CCHLO computation graph. This achieves decoupling between ciphertext computation logic and business code at the HLO computation graph level. Thus, without modifying the original business code or understanding new syntax logic, programmers without cryptographic backgrounds can determine visibility, enabling code with privacy-preserving computation semantics. Furthermore, based on the combination of multi-point confidential containers and additive secret sharing, and leveraging the ability of additive secret sharing to fragment plaintext into any number of pieces, it supports any number of data parties participating in the same computation task. It can perform ciphertext adaptation for all HLO operators, supporting arbitrary HLO ciphertext computation, avoiding complex cryptographic protocols, completing encrypted operations with only a few interactions, and exhibiting extremely low performance overhead from encryption.

[0018] In addition, the multi-party collaborative computing system based on confidential containers and additive secret sharing of the present invention also has the above-mentioned advantages.

[0019] In addition to the objectives, features, and advantages described above, the present invention has other objectives, features, and advantages. The invention will now be described in further detail with reference to the figures. Attached Figure Description

[0020] The accompanying drawings, which form part of this application, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an undue limitation of the invention. In the drawings: Figure 1This is a flowchart illustrating a preferred embodiment of the multi-party collaborative computing method based on a confidential container and additive secret sharing. Figure 2 yes Figure 1 A schematic diagram of the sub-process of step S2; Figure 3 This is a schematic diagram of the module structure of a multi-party collaborative computing system based on a confidential container and additive secret sharing, according to another embodiment of this application. Detailed Implementation

[0021] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. This application will now be described in detail with reference to the accompanying drawings and embodiments.

[0022] Reference Figure 1 A preferred embodiment of this application provides a multi-party collaborative computing method based on a confidential container and additive secret sharing, including the following: Step S1: Write the original business code according to the business situation and distribute it to each participant. Each participant compiles the original business code into an HLO computation graph. Step S2: Configure visibility rules and visibility inference mechanism, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanism, and distribute them to each participant; Step S3: Each participant binds the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file to generate the CCHLO computation graph; Step S4: Each participant uses a confidential container and additive secret sharing to perform multi-party collaborative computation based on the CCHLO computation graph to obtain the joint computation result.

[0023] It is understood that the multi-party collaborative computation method based on confidential containers and additive secret sharing in this embodiment configures the visibility of all nodes in the HLO computation graph through configured visibility rules and visibility inference mechanisms, generating a CCHLO computation graph. This achieves decoupling between ciphertext computation logic and business code at the HLO computation graph level. Therefore, without modifying the original business code or understanding new syntax logic, programmers without cryptographic backgrounds can determine visibility, thus enabling code with privacy-preserving computation semantics. Furthermore, based on the combination of multi-point confidential containers and additive secret sharing, and leveraging the ability of additive secret sharing to fragment plaintext into any number of pieces, it supports any number of data parties participating in the same computation task. It can perform ciphertext adaptation for all HLO operators, supporting arbitrary HLO ciphertext computation, avoiding the involvement of complex cryptographic protocols, completing encrypted operations with only a few interactions, and resulting in extremely low performance overhead from encryption operations.

[0024] In step S1, based on the plaintext business logic, original business code is written using common front-ends (such as TensorFlow, PyTorch, etc.). This original business code is transmitted in plaintext and distributed to each participant. Each participant prepares a rich computing environment (i.e., a common server, PC, etc., responsible for computation and network communication) and a confidential container environment (e.g., an open-source and trimmed Linux operating system, a confidential virtual machine, etc.). The confidential container environment requires a boot image and ultimately provides services externally via network interaction such as HTTP. The code within the image mainly contains all the computational parts required to be executed in the confidential container in the subsequent CCHLO algorithm. A participant's confidential container only communicates with its own rich computing environment via the network. In addition, each participant has installed the XLA compiler and a cryptographic interpreter locally. The XLA compiler is a dedicated compiler backend designed by Google for machine learning workloads, which can transform high-level tensor operations into efficient low-level code (such as CUDA, TPU instructions, etc.). The cryptographic interpreter is responsible for scheduling multi-party collaborative computation based on the HLO computation graph, visibility files, local input data, participant environments, and local confidential container environments. Both are installed in rich computing environments. After receiving the original business code, each participant uses the locally deployed XLA compiler to translate the original business code into an HLO computation graph through static compilation. The HLO computation graph is a high-level intermediate representation used by the XLA compiler. The upper-level tasks, after compilation, usually form a composite of several operators, forming a graph that can be regarded as a directed acyclic graph.

[0025] Furthermore, in step S2, due to security and privacy considerations, the data (including input data, intermediate data, and results) is not visible to all participants. Therefore, it is necessary to configure the visibility state of the data. The visibility rules configured in this invention only consider three visibility states: private, secret, and public. The private state indicates that the data is visible to a specified participant; the secret state indicates that the data is not visible to any participant; and the public state indicates that the data is visible to all participants. The private state only appears in the initial input and final result data; the data throughout the entire calculation process is in either the secret or public state. Moreover, this invention also configures a visibility inference mechanism, including: in multivariate operations, the result obtained after calculating data in the secret state with data in any state is in the secret state; in unary operations (i.e., calculations requiring only one input, such as calculating the value of a sine function), the visibility state of the result is consistent with the visibility state of the input; and the result of constant operations (e.g., defining a constant value, generating a random number) is in the public state.

[0026] After configuring the data visibility rules and visibility inference mechanism, visibility configuration files for all nodes in the HLO computation graph can be generated based on the configured visibility rules and visibility inference mechanism, and then distributed to all participants. For example, Figure 2 As shown, the process of generating visibility profiles for all nodes in the HLO computation graph based on configured visibility rules and visibility inference mechanisms includes the following: Step S21: Traverse the HLO computation graph, identify all sets of start nodes with an in-degree of zero, and subdivide the set of start nodes into three subsets according to the operator semantics: parameter node set, constant node set, and random operator set. Step S22: Configure the visibility state of each subset; wherein, the visibility state of each node in the same subset is the same; Step S23: Based on the configured visibility inference mechanism and the visibility state of the node itself, deduce the visibility state of all intermediate nodes; Step S24: Configure the visibility state of the final node in the HLO computation graph to obtain the visibility configuration file for all nodes.

[0027] Specifically, the HLO computation graph is viewed as a directed acyclic graph. First, traverse the HLO computation graph. G Identify the set of all starting nodes with an in-degree of 0. I According to the operator semantics I It is further divided into the following three subsets: parameter node set (Representing data provided externally), constant node set (Represents hard-coded values ​​in the code), random operator set (This represents the pseudo-random numbers that need to be generated temporarily). Then, configure the visibility state of each subset. In this subset, all nodes have the same visibility state. Optionally, for and Its visibility status Configured as public, for Its visibility status The visibility state is configured as either public or secret. Then, based on the configured visibility inference mechanism and the node's own visibility state, the visibility state of all intermediate nodes is derived. For example, in multivariate operations, the result obtained after computing data in a secret state with data in any state is secret; the visibility state of the result of a unary operation is consistent with the input state, etc. The user can set the visibility state of any intermediate node. Configure it so that after the visibility state changes, all backward nodes of that node will be affected. The state is re-inferred, but this excludes nodes that have been manually set in the backward nodes. This means that user-defined settings are always the highest priority, with automatic inference only serving as an auxiliary method. Finally, the visibility state of the final node in the HLO computation graph is configured as public or private. If configured as private, the visible participant information must also be specified, which can be represented as follows: , This specifies the set of visible participants, and then derives the visibility state of all nodes. This will generate the visibility configuration file for all nodes. V config .

[0028] Furthermore, in step S3, after generating the visibility profile and HLO computation graph, HLO operator information with visibility information (secret / public) has already been obtained. Therefore, it is only necessary to ensure that all HLO operators are executed correctly while meeting the visibility requirements. Thus, each participant binds the visibility attributes of all nodes in the HLO computation graph according to the received visibility profile, generating the CCHLO computation graph. For example, it traverses all nodes and... V config The corresponding visibility state Bind to a node. After binding is complete, the HLO computation graph will be converted into a CCHLO computation graph. G cc Subsequent multi-party collaborative computation is performed based on the CCHLO computation graph. It can be understood that HLO (High Level Optimizer) is the core intermediate representation (IR) of the XLA compiler. It uses a set of platform-independent high-level operations (such as matrix multiplication and convolution) to describe the computation graph of deep learning models, serving as a bridge connecting front-end machine learning frameworks (such as TensorFlow, PyTorch, and JAX) with various back-end hardware (CPU, GPU, TPU). The CCHLO (Confidential-Computing High-Level Operations) computation graph of this invention expands upon the existing HLO computation graph by adding the visibility states of the inputs and outputs of each high-level operation (such as matrix multiplication and convolution), serving as a bridge connecting front-end machine learning frameworks (such as TensorFlow, PyTorch, and JAX) with the back-end confidential container environment.

[0029] Additionally, in step S4, after obtaining G cc Afterwards, it is necessary to ensure that all parties can actually calculate... G ccEach participant employs confidential containers and additive secret sharing techniques to conduct multi-party collaborative computation based on the CCHLO computation graph to obtain joint computation results. The use of confidential containers and additive secret sharing techniques offers the following advantages: 1. Based on the same random seed, the same string of pseudo-random numbers can be generated in different confidential container environments, and this string of random data cannot be detected externally; 2. The same random seed can be negotiated and generated across multiple different confidential container environments using public-key encryption algorithms (such as DH key negotiation); 3. Even if only one share value is missing, the actual data cannot be deduced; furthermore, in the CCHLO computation graph, since the order of data computation is deterministic and known to all participants, the position of the pseudo-random number to be used in subsequent algorithms is also known to all parties.

[0030] Among them, the whole G cc The nodes in the CCHLO computation graph can be divided into three main categories: start nodes, intermediate nodes, and output nodes (i.e., final nodes). In the process of multi-party collaborative computation based on the CCHLO computation graph, for each node in the CCHLO computation graph, if the node is a start node, the operator is executed only based on the visibility state of the node itself. If the node is an intermediate node or a final node, the operator is executed based on the visibility state of all in-degree nodes and the visibility state of the node itself.

[0031] Among them, for the input node in the CCHLO computation graph, it belongs to Its essence is to calculate the private-to-secret transfer (referred to as the pr2s algorithm in this invention) (when the node's (Secret), private to public (this invention is referred to as the pr2p algorithm) (when the node's (For public purposes), it requires the following computation at the interpreter level: If the visibility state of the input node is configured as secret, then the participants corresponding to the input node (i.e., the participants that provided the input data) will have their visibility determined by the number of participants. n Randomly generated in a local rich computing environment n -1 data and calculate , d This indicates the input data, and based on the numbers of the other participants, the corresponding... The value is sent to the corresponding participant, and each participant responds according to the received value. The value is executed by the operator; if the visibility state of the input node is configured to public, then the participant corresponding to the input node directly submits the input data. d The operator is sent to a specific participant, who then executes it. This specific participant can be any participant. Additionally, for the set of constant nodes in the CCHLO computation graph... and random operator sets Operators are executed directly by a specific participant in the local rich computing environment. The specific participant can be any participant, and other participants may choose not to execute this part of the operator.

[0032] It is understandable that since the unencrypted computation in the entire computation graph actually only needs to be performed by one party (i.e., a specific participant, hereinafter referred to as P1), and from a security perspective, if a party other than itself knows the plaintext data, it is equivalent to making it public, and the specific participant can be any party, with the specific participant bearing the heavier computational task, different computation graphs can set different specific participants, thereby supporting load balancing and improving computational and network efficiency.

[0033] In addition, for intermediate nodes in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, then the specific participant side must have the required plaintext input data, and the specific participant can perform plaintext computation in its local rich computing environment.

[0034] If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is secret, it means that a specific participant must possess the required plaintext input data. Therefore, an in-degree state of [missing information] can be used. k The operator is f The p2s (public-to-secret) algorithm is as follows: all participants first generate the same random sequence based on the same random seed in their own confidential container environment. A specific participant will collect all in-degree node data. (Plaintext data) is sent to a local confidential container environment to execute the operator. Then, calculate Then The data is sent from the confidential container environment to the rich computing environment, while other participants obtain it directly from their own confidential container environment. ;in, k This represents the in-degree of the intermediate node. n Indicates the number of shards in the encrypted secret sharing, subscript i Indicates the first i Slice addition sharing value.

[0035] If there exists at least one in-degree node whose visibility state is secret, and the node itself whose visibility state is also secret, then an in-degree state of secret can be used. k The operator is f The S2S (Secret to Secret) process involves all participants first generating the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. , Indicates the first t The first input value i The secret value of addition is shared. , superscript t Indicates the position of the input data in the in-degree, index. i This indicates the location of the data in the addition fragment. If the data has no index, it means it is plaintext, not an encrypted shared value. The confidential container environment will then... Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculations yielded Then calculate Then Send from a confidential container environment to a specific participant In a rich computing environment, the remaining participants ( Obtained from our confidential container environment Additionally, for the remaining in-degree nodes whose visibility state is public, the p2s algorithm described above can be used to convert public to private.

[0036] If at least one in-degree node has a visibility state of secret, and the node itself has a visibility state of public, then the in-degree can be set to... k The operator is f The S2P (Secret to Public) algorithm works as follows: all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculation Obtain plaintext data Then calculate Finally z Send from a confidential container environment to a specific participant In a rich computing environment. Furthermore, if the visibility state of the remaining in-degree nodes is public, then the plaintext computation described above can be used.

[0037] In addition, for the final node in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, the specific participant side must have the required plaintext input data, and can perform plaintext computation in its rich computing environment, and then broadcast the computation result to all participants.

[0038] If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is private. Then the in-degree can be used as k The operator is f The p2pr (public-to-private) algorithm works as follows: all participants first generate the same random sequence in their own confidential container environment based on the same random seed. A specific participant will collect all in-degree node data. Send to a local confidential container environment to perform operator computation: , f Describe the operators, and then calculate them separately. Then From a confidential container environment, data is sent to a rich computing environment of a specific participant. The specific participant then assigns the corresponding data based on its participant ID. Send to the specified visible participants, who then obtain the information from their own confidential container environment. And compute in a local rich computing environment .

[0039] If at least one in-degree node has a visibility state of secret, and the node itself has a visibility state of public, then the in-degree can be set to... k The operator is f The S2P (public-to-secret) algorithm works as follows: all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculation Obtain plaintext data Then calculate Finally z Send from a confidential container environment to a specific participant In rich computing environments, specific stakeholders Will z Send to the other participants ( Additionally, if the visibility state of the remaining in-degree nodes is public, the plaintext calculation described above can be used.

[0040] If at least one in-degree node has a visibility state of secret, and the node itself has a visibility state of private, then an in-degree state of secret can be used. k The operator is f The S2PR (Secret to Private) algorithm works as follows: all participants first generate the same random sequence in their own confidential container environment based on the same random seed. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within its confidential container. , Indicates the first t The first input value i The secret value of addition is shared. , Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node ( )Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation And further calculations yielded Then calculate Then Sending from a confidential container environment to a rich computing environment by specific stakeholders Will Send to the specified visible participants Specify visible participants to obtain from their own confidential container environment And compute in a rich computing environment Additionally, for the remaining in-degree nodes whose visibility state is public, the p2pr algorithm described above can be used to convert public to private.

[0041] It is understood that this invention is based on the idea of ​​combining multi-point confidential containers with additive secret sharing. Through the above-mentioned multiple algorithm mechanisms, it ensures the feasibility of implementing visibility rules and visibility inference mechanisms, significantly improves the efficiency of confidential computation, and avoids the high cost of pure confidential container schemes. It can complete the secure confidential execution of all operators in HLO under any participating party.

[0042] In addition, such as Figure 3 As shown, another embodiment of the present invention also provides a multi-party collaborative computing system based on confidential containers and additive secret sharing, preferably employing the multi-party collaborative computing method based on confidential containers and additive secret sharing as described above, including: The HLO computation graph generation module is used to write original business code based on business conditions and distribute it to each participant. Each participant compiles the original business code into an HLO computation graph. The visibility file configuration module is used to configure visibility rules and visibility inference mechanisms, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanisms, and distribute them to each participant; The CCHLO computation graph generation module is used by each participant to bind the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file, and generate the CCHLO computation graph. The multi-party collaborative computing module is used by participating parties to share confidential containers and additive secrets, and to perform multi-party collaborative computing based on the CCHLO computing graph to obtain joint computing results.

[0043] It is understood that the multi-party collaborative computing system based on confidential containers and additive secret sharing in this embodiment configures the visibility of all nodes in the HLO computation graph through configured visibility rules and visibility inference mechanisms, generating a CCHLO computation graph. This achieves decoupling between ciphertext computation logic and business code at the HLO computation graph level. Thus, without modifying the original business code or understanding new syntax logic, programmers without cryptographic backgrounds can determine visibility and implement code with privacy-preserving computation semantics. Furthermore, based on the combination of multi-point confidential containers and additive secret sharing, and leveraging the ability of additive secret sharing to fragment plaintext into any number of pieces, it supports any number of data parties participating in the same computation task. It can perform ciphertext adaptation for all HLO operators, supports arbitrary HLO ciphertext computation, avoids complex cryptographic protocols, completes encrypted operations with only a few interactions, and suffers minimal performance loss from encryption.

[0044] In addition, another embodiment of the present invention provides an electronic device including a processor and a memory, wherein the memory stores a computer program, and the processor executes the steps of the method described above by calling the computer program stored in the memory.

[0045] In addition, another embodiment of the present invention provides a computer-readable storage medium for storing a computer program for multi-party collaborative computation based on a confidential container and additive secret sharing, wherein the computer program executes the steps of the method described above when running on a computer.

[0046] Common computer-readable storage media include: floppy disks, flexible disks, hard disks, magnetic tapes, any other magnetic media, CD-ROMs, any other optical media, punch cards, paper tape, any other physical media with perforated patterns, random access memory (RAM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), flash erasable programmable read-only memory (FLASH-EPROM), any other memory chips or cartridges, or any other media readable by a computer. Instructions may further be transmitted or received by a transmission medium. The term transmission medium can include any tangible or intangible medium used to store, encode, or carry instructions for execution by a machine, and includes digital or analog carrier communication signals or intangible media that facilitate communication of such instructions. Transmission media include coaxial cables, copper wires, and optical fibers, which contain conductors for transmitting a bus of computer data signals.

[0047] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code. The solutions in the embodiments of this application can be implemented in various computer languages, such as the object-oriented programming language Java and the interpreted scripting language JavaScript.

[0048] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0049] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0050] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0051] Although preferred embodiments of this application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of this application.

[0052] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

[0053] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A multi-party collaborative computing method based on confidential containers and additive secret sharing, characterized in that, Includes the following: Based on the business situation, the original business code is written and distributed to each participant. Each participant compiles the original business code into an HLO computation graph. Configure visibility rules and visibility inference mechanisms, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanisms, and distribute them to all participants; Each participant binds the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file, generating the CCHLO computation graph; Each participant uses confidential containers and additive secret sharing to perform multi-party collaborative computation based on the CCHLO computation graph to obtain joint computation results; For intermediate nodes in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, then the specific participant will perform plaintext computation in the local rich computing environment. If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is secret, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. A specific participant will collect all in-degree node data. Send to a local confidential container environment to execute the operator Then, calculate Then The data is sent from the confidential container environment to the rich computing environment, while other participants obtain it directly from their own confidential container environment. ;in, k This represents the in-degree of the intermediate node. n Indicates the number of shards in the encrypted secret sharing, subscript i Indicates the first i Slice addition sharing value; If at least one in-degree node has a secret visibility state, and the node itself also has a secret visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. , Indicates the first t The first input value i The secret value of addition is shared in slices. , Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node , ,Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation , And further calculations yielded Then calculate Then Send from a confidential container environment to a specific participant In a rich computing environment, the remaining participants , Obtained from our confidential container environment ; If at least one in-degree node has a secret visibility state and the node itself has a public visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node , ,Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation , And further calculation Obtain plaintext data Then calculate Finally z Send from a confidential container environment to a specific participant In a rich computing environment; For the final node in the CCHLO computation graph, if the visibility state of all in-degree nodes is public, and the visibility state of the node itself is also public, then the specific participant will perform plaintext computation in the local rich computing environment. If the visibility state of all in-degree nodes is public, and the visibility state of the node itself is private, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. A specific participant will collect all in-degree node data. Send to a local confidential container environment to perform operator computation: , f Describe the operators, and then calculate them separately. , and then f Describe the operators, and then calculate them separately. Then And compute in a local rich computing environment ; If at least one in-degree node has a secret visibility state and the node itself has a public visibility state, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node , ,Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation , And further calculation Obtain plaintext data Then calculate Finally z Send from a confidential container environment to a specific participant In rich computing environments, specific stakeholders Will z Send to the other participants , ; If at least one in-degree node has a visibility state of secret, and the node itself has a visibility state of private, then all participants first generate the same random sequence based on the same random seed within their own confidential container environment. The participants corresponding to each in-degree node The data they hold The data is sent to each party's confidential container environment, where each party performs its own calculations within the confidential container. , Indicates the first t The first input value i The secret value of addition is shared in slices. , Confidential container environment Send to the rich computing environment, the participants corresponding to each in-degree node , ,Will Send to specific participants Specific participants will then and Send to our confidential container environment for computation , And further calculations yielded Then calculate Then Sending from a confidential container environment to a rich computing environment by specific stakeholders Will Send to the specified visible participants Specify visible participants to obtain from their own confidential container environment And compute in a rich computing environment .

2. The multi-party collaborative computing method based on confidential containers and additive secret sharing as described in claim 1, characterized in that, The process of generating visibility profiles for all nodes in the HLO computation graph based on configured visibility rules and visibility inference mechanisms includes the following: Traverse the HLO computation graph, identify all sets of start nodes with an in-degree of zero, and subdivide the set of start nodes into three subsets based on operator semantics: parameter node set, constant node set, and random operator set. Configure the visibility state of each subset; wherein, the visibility state of all nodes in the same subset is the same; Based on the configured visibility inference mechanism and the visibility state of the node itself, the visibility state of all intermediate nodes is derived. Configure the visibility state of the final node in the HLO computation graph to obtain the visibility configuration file for all nodes.

3. The multi-party collaborative computing method based on confidential containers and additive secret sharing as described in claim 2, characterized in that, The visibility inference mechanism includes: in multivariate operations, the result obtained after calculating the data in the secret state and the data in any state is the secret state; in unary operations, the visibility state of the result is consistent with the visibility state of the input; and the result of constant operations is the public state.

4. The multi-party collaborative computing method based on confidential containers and additive secret sharing as described in claim 2, characterized in that, In the process of multi-party collaborative computation based on the CCHLO computation graph, for each node in the CCHLO computation graph, if the node belongs to the starting node, the operator is executed only based on the visibility state of the node itself.

5. The multi-party collaborative computing method based on confidential containers and additive secret sharing as described in claim 4, characterized in that, For an input node in the CCHLO computation graph, if the visibility state of that input node is configured as secret, the number of participants corresponding to that input node will be determined based on the number of participants. n Randomly generated in a local rich computing environment n -1 data and calculate , d This indicates the input data, and based on the numbers of the other participants, the corresponding... The value is sent to the corresponding participant, and each participant responds according to the received value. The value is executed by the operator; if the visibility state of the input node is configured to public, then the participant corresponding to the input node directly submits the input data. d Send to a specific participant, who then executes the operator, where the specific participant can be any participant.

6. The multi-party collaborative computing method based on confidential containers and additive secret sharing as described in claim 4, characterized in that, For the constant node set and random operator set in the CCHLO computation graph, the operators are executed directly by a specific participant in the local rich computing environment, where the specific participant can be any participant.

7. A multi-party collaborative computing system based on confidential containers and additive secret sharing, employing the multi-party collaborative computing method based on confidential containers and additive secret sharing as described in any one of claims 1 to 6, characterized in that, include: The HLO computation graph generation module is used to write original business code based on business conditions and distribute it to each participant. Each participant compiles the original business code into an HLO computation graph. The visibility file configuration module is used to configure visibility rules and visibility inference mechanisms, and generate visibility configuration files for all nodes in the HLO computation graph based on the configured visibility rules and visibility inference mechanisms, and distribute them to each participant; The CCHLO computation graph generation module is used by each participant to bind the visibility attributes of all nodes in the HLO computation graph based on the visibility configuration file, and generate the CCHLO computation graph. The multi-party collaborative computing module is used by participating parties to share confidential containers and additive secrets, and to perform multi-party collaborative computing based on the CCHLO computing graph to obtain joint computing results.

8. An electronic device, characterized in that, The method includes a processor and a memory, wherein the memory stores a computer program, and the processor executes the steps of the method as described in any one of claims 1 to 6 by calling the computer program stored in the memory.

9. A computer-readable storage medium for storing a computer program for multi-party collaborative computation based on a confidential container and additive secret sharing, characterized in that, The computer program, when run on a computer, performs the steps of the method as described in any one of claims 1 to 6.

Images