CN111753315A

CN111753315A - Input data calculation method, calculation engine and storage medium

Info

Publication number: CN111753315A
Application number: CN201910252632.XA
Authority: CN
Inventors: 李艺
Original assignee: Huakong Tsingjiao Information Technology Beijing Co Ltd
Current assignee: Huakong Tsingjiao Information Technology Beijing Co Ltd
Priority date: 2019-03-29
Filing date: 2019-03-29
Publication date: 2020-10-09
Anticipated expiration: 2039-03-29
Also published as: CN111753315B; WO2020199784A1

Abstract

The application provides a computing method, a computing engine and a storage medium of input data. The multi-party computing method comprises the steps that a computing engine cooperatively computed by four computing nodes is used for executing computing tasks, wherein the computing engine acquires multi-party computing instructions corresponding to the computing tasks and acquires private data sets; each private data set is obtained by input data based on a random decentralized processing mode required by a computation engine to execute multi-party computation; according to the multi-party calculation instruction, each calculation node respectively carries out local calculation on the private data group acquired by each calculation node, and intermediate data generated by the local calculation are interacted to obtain calculation results respectively held by each calculation node; wherein, the calculation results held by part of the calculation nodes selected from the four calculation nodes are used for generating a processing result; wherein, the processing result is the processing result of the input data processed by the computing task. The method and the device effectively improve the data transmission quantity of the four computing nodes for multi-party computing and reduce the computing complexity.

Description

Input data calculation method, calculation engine and storage medium

Technical Field

The present application relates to the field of data processing technologies, and in particular, to a computing method, a computing engine, and a storage medium for input data.

Background

The development of big data services is promoted by the intellectualization of electronic equipment and the Internet, and meanwhile, the life habits of people are changed under the guidance of more convenience and operability of the big data services. For example, the credit rating of the user/business at each bank may facilitate the lender in evaluating the lending ability of the borrower. For another example, when people go out collectively, the people share the navigation route to be beneficial to contacting each other. For another example, enterprises can share data to process data so as to provide more accurate statistical information for clients.

As big data is shared between enterprises, between enterprises and individuals, and between individuals, some private data, such as bank credit rating, personal identity information, personal consumption information, etc., may be revealed along with data traffic. As user behaviors and habits are collected in a data-based manner, users/enterprises pay more and more attention to private data. Therefore, data sharing services and private data privacy become an increasingly prominent pair of contradictions.

Disclosure of Invention

In view of the above-mentioned shortcomings of the prior art, the present application aims to provide a computing method, a computing engine and a storage medium for input data, which are used for solving the problem that the computing efficiency of multi-party computing in the prior art is far lower than the user requirement.

To achieve the above and other related objects, a first aspect of the present application provides a method for computing input data, which utilizes a computation engine cooperatively computed by four computation nodes to compute a multi-party computation instruction corresponding to a computation task, wherein the computation task is used for performing data processing on the input data, and the method comprises: the computing engine acquires a multi-party computing instruction and a private data set; each private data set is obtained by the input data based on a random decentralized processing mode required by the computation engine to execute multi-party computation; according to the multi-party calculation instruction, at least part of calculation nodes in the calculation engine respectively carry out local calculation on the private data groups acquired by the calculation nodes, and/or intermediate data generated by the local calculation are interacted, so that calculation results respectively held by the calculation nodes are obtained; wherein, the calculation results held by part of the calculation nodes selected from the four calculation nodes are used for generating a processing result; wherein the processing result is a processing result of the computing task processing the input data.

In certain embodiments of the first aspect of the present application, the random dispersion treatment comprises: at least one private data is randomly generated based on the number of computing nodes executing the computing task, and the input data X is subjected to decentralized processing according to the generated private data.

In certain embodiments of the first aspect of the present application, the input data comprises a numerical value X; the random dispersion treatment mode comprises the following steps: randomly generating two private data x₁And x'₁Based on the private data x₁And x'₁Scatter input data X into { X₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_b}; wherein x is₂＝X-x₁＝x_a，x₁＝x_b，x'₂＝X-x'₁＝x'_b，x'₁＝x'_a(ii) a The private data corresponding to the input data X in the private data set acquired by each computing node are respectively { X }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}。

In certain embodiments of the first aspect of the present application, the input data comprises a bit value C; the random dispersion treatment mode comprises the following steps: randomly generating private data c of two bits₁And c'₁Based on said private data c₁And c'₁The input data C is dispersed into private data C expressed in bits₁,c'₁,c₂,c'₂,c_a,c'_a,c_b,c'_b}; wherein the content of the first and second substances,

c₁＝c_b，

c'₁＝c'_a(ii) a The private data corresponding to the input data C in the private data set acquired by each computing node are respectively { C }₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}。

In certain embodiments of the first aspect of the present application, the input data comprises floating point type data; the private data is obtained by performing random dispersion processing on the binary floating point type data.

In certain embodiments of the first aspect of the present application, the computing engine further obtains non-private data as input data; the multi-party computing instruction is determined from the non-private data.

In certain embodiments of the first aspect of the present application, the multi-party computing instructions comprise instructions arranged based on an associative relationship between a plurality of computations in a computing task

In certain embodiments of the first aspect of the present application, each computing node performs local computations using a shared random number to obtain intermediate data or computation results that can be cancelled; wherein each computing node is provided with a random number generator that generates the random number.

In certain embodiments of the first aspect of the present application, the computational task comprises a mathematical computational task of two input data; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises the following steps: and enabling the four computing nodes to execute local computation by using the random numbers and obtain respectively held computing results by using data interaction of once replacement data.

In certain embodiments of the first aspect of the present application, the computational task comprises a multiplication computational task of two input data; according to the multi-party calculation instruction, each calculation node respectively carries out local calculation on the private data group acquired by each calculation node, and intermediate data generated by the local calculation are interacted to obtain the private data groupThe steps of calculating the calculation results held by the nodes respectively include: a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x }₁,x'₁,y₁,y'₁}, private data set { x₂,x'₂,y₂,y'₂}, private data set { x_a,x'_a,y_a,y'_aAnd a private data set { x }_b,x'_b,y_b,y'_b}; wherein, { x₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bThe data X is obtained by random decentralized processing of input data, y₁,y'₁,y₂,y'₂,y_a,y'_a,y_b,y'_bThe data Y is obtained by performing random dispersion processing on the input data Y.

Wherein, according to a multi-party computing instruction generated by executing a multiplication task of input data X and Y by four computing nodes, the computing engine executes the following steps: enabling the first computing node and the second computing node to share a random number r₁₂And r'₁₂And having said third and fourth computing nodes share a random number r_abAnd r'_ab(ii) a The first computing node and the second computing node respectively carry out multiplication computation on the private data groups held by the first computing node and the second computing node and are used for offsetting the random number r₁₂And r'₁₂So that the first computing node gets the intermediate data t₁And t'₁And the second computing node obtains the intermediate data t₂And t'₂(ii) a The third computing node and the fourth computing node respectively carry out multiplication computation on the private data groups held by the third computing node and the fourth computing node and are used for offsetting the random number r_abAnd r'_abSo that the first computing node gets the intermediate data t_aAnd t'_aAnd the second computing node obtains the intermediate data t_bAnd t'_b(ii) a Causing the first compute node and the third compute node to permute a respective one of the intermediate data, and the first compute node and the fourth compute node to permute a respective one of the intermediate data; order toThe second computing node and the third computing node permute a respective one of the intermediate data, and the second computing node and the fourth computing node permute a respective one of the intermediate data; and enabling each computing node to perform local computation including addition by using the intermediate data paired based on the permutation operation, so that each computing node obtains two computation results including the cancelable random numbers.

In certain embodiments of the first aspect of the present application, the computing task comprises a computing task of a mathematical computation of two input data, the computing engine producing no more than 2 x 4 permutations of data-based communications during execution of the computing task.

In certain embodiments of the first aspect of the present application, the computing engine generates data traffic of no more than 2n × 4 bits of data during execution of the computing task, where n is a range of values for private data and a shared random number

In certain embodiments of the first aspect of the present application, the computational tasks comprise three computational tasks of mathematical computation of the input data; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises the following steps: enabling the four computing nodes to obtain first computing results of respective held corresponding input data X and Y computing by utilizing data interaction of the first replacement data and taking the first computing results as intermediate data; enabling the four computing nodes to obtain the computing results held by the computing nodes by utilizing data interaction of the intermediate data for replacing the data for the second time; and having four of the compute nodes perform local computations based on the random numbers before permuting the data twice.

In some embodiments of the first aspect of the present application, according to the multi-party computing instruction, the step of performing local computation on the private data groups obtained by the respective computing nodes, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the respective computing nodes includes: a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x1, y1 ', z1}, a private data set { x2, y 2', z2}, a private data set { xa, ya ', za }, and a private data set { xb, yb', zb }; wherein { X1, X2, xa, xb } is obtained by subjecting input data X to random dispersion processing, { Y1 ', Y2', ya ', yb' } is obtained by subjecting input data Y to random dispersion processing, and { Z1, Z2, za, zb } is obtained by subjecting input data Z to random dispersion processing; in accordance with multi-party computing instructions generated by performing a multiply compute task of input data X, Y and Z using four compute nodes, the compute engine performs the steps of:

enabling the first computing node and the second computing node to share a random number

And enabling the third computing node and the fourth computing node to share a random number

Four of the computing nodes are caused to multiply private data relating to input data X and Y and to cancel a random number, respectively

And

so that the first computing node gets the intermediate data t₁The second computing node obtains intermediate data t₂The third computing node obtains intermediate data t_aThe fourth computing node obtains intermediate data t_b(ii) a The first computing node and the third computing node replace respective intermediate data; the second computing node and the third computing node replace respective intermediate data; each computing node performs mathematical computation of multiplication by using each held intermediate data and private data corresponding to the input data Z, so that the first computing node obtains the intermediate datas₁The second computing node obtains intermediate data s₂The third computing node obtains intermediate data s_aThe fourth computing node obtains intermediate data s_b(ii) a The first computing node and the second computing node respectively carry out the mutual held intermediate data s₁And s₂Performing multiplication and for cancelling the random number r₁₂And r'₁₂So that the first computing node obtains intermediate data h₁And h'₁And the second computing node obtains intermediate data h₂And h'₂(ii) a The third computing node and the fourth computing node respectively carry out the mutual held intermediate data s_aAnd s_bPerforming multiplication and for cancelling the random number r_abAnd r'_abSo that the third computation node gets the intermediate data h_aAnd h'_aAnd the fourth computing node obtains intermediate data h_bAnd h'_b(ii) a Causing the first compute node and the third compute node to permute a respective one of the intermediate data, and the first compute node and the fourth compute node to permute a respective one of the intermediate data; causing the second compute node and the third compute node to permute a respective one of the intermediate data, and the second compute node and the fourth compute node to permute a respective one of the intermediate data; and enabling each computing node to perform local computation including addition by using the intermediate data paired based on the permutation operation, so that each computing node obtains two computation results including the cancelable random numbers.

In certain embodiments of the first aspect of the present application, the computing task comprises a computing task of a mathematical computation of three input data, the computing engine producing no more than 3 x 4 data communications based on permuted data during execution of the computing task.

In certain embodiments of the first aspect of the present application, the computing engine generates data traffic of no more than 3n × 4 bits of data during execution of the computing task, where n is a range of values Z of private data and a shared random number_2n。

In certain embodiments of the first aspect of the present application, the computational tasks include a computational task that extracts binary bits in the input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises: the four computing nodes use data of k rounds of 1-bit replacement to interact to obtain respective supported computing results, wherein the computing results are used for extracting binary bits in the input data X; and k is the binary digit number to be extracted corresponding to the input data X in the calculation task.

In certain embodiments of the first aspect of the present application, each compute node produces no more than k +1 data communications.

In certain embodiments of the first aspect of the present application, each computing node produces data communications of no more than a2 kbit data volume.

In certain embodiments of the first aspect of the present application, the computational tasks include a computational task that extracts binary bits in the input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises: a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x }₁}, private data set { x₂}, private data set { x_aAnd a private data set { x }_b}; wherein, { x₁,x₂,x_a,x_bThe secret data are binary expressed secret data obtained by carrying out random dispersion processing on the input data X, wherein each secret data and the input data X have the same binary digit number k; according to the calculation instruction, the calculation engine executes the following steps:

each compute node initializes a bit value for output { c }₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}; and sharing the first computing node and the second computing nodeRandom number r₁₂And b₁₂(ii) a And making the third computing node and the fourth computing node share a random number b_ab(ii) a Wherein the random number r₁₂、b₁₂And b_abIs a binary random number generated based on the number of extracted bits k; the first computing node and the second computing node use the random number r₁₂For respectively held private data x₁And x₂Logic processing is carried out on the low-k bits to obtain binary intermediate data u with low-k bits unified₁And u₂(ii) a Let the first computing node intermediate data u₁Sent to the third computing node and processed by the third computing node based on the formula u₁∧x_aAnd obtaining intermediate data u_a(ii) a Based on the k value, the following loop calculation is set: each computing node is used for generating private data x₁With the random number b based on the sharing₁₂Or b_abAnd obtaining the intermediate data of the ith round; performing replacement processing on the intermediate data obtained in each turn, and assigning corresponding output bits; the first computing node and the third computing node perform replacement processing on the intermediate data, and the second computing node and the fourth computing node perform replacement processing on the intermediate data; each computing node utilizes the assigned output bit and the random number to carry out logic computation on the k bit value of the private data held by each computing node to obtain a computation result; the first computing node is to compute result c'₁To a third computing node; the second computing node will compute result c'₂To a fourth computing node; the third computing node will compute the result c_aTo a second computing node; the fourth computing node calculates the result c_bProvided to the first compute node so that each compute node holds two compute results.

In certain embodiments of the first aspect of the present application, each compute node produces no more than 1.5 kbit data communications.

In certain embodiments of the first aspect of the present application, the computation task includes a computation task that compares two input data, and the four computation nodes are caused to perform local computation and data interaction according to a multiparty computation instruction set based on a subtraction computation task and a bit extraction computation task of the two input data, so as to obtain bit values held by the computation nodes.

In some embodiments of the first aspect of the present application, the step of, according to the calculation instruction, performing local calculation on the private data groups acquired by the respective computing nodes respectively by the respective computing nodes, and performing interaction on intermediate data generated by the local calculation to obtain calculation results held by the respective computing nodes respectively includes: and executing multi-party calculation instructions set based on the careless transmission protocol by using four calculation nodes and obtaining calculation results held by the calculation nodes.

In certain embodiments of the first aspect of the present application, the step of executing, by four computing nodes, a multiparty computing instruction set based on an oblivious transfer protocol and obtaining computing results held by each computing node includes: enabling the four computing nodes to perform local computation and data interaction based on sharable random bit values used for indicating transmission/non-transmission of corresponding private data, and obtaining respective computation results; wherein the calculation result comprises a result for indicating that the corresponding private data is transmitted or a result for indicating that the corresponding private data is not transmitted.

In certain embodiments of the first aspect of the present application, the computing task comprises a computing task that inadvertently transmits input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises: the private data obtained by each computing node in the computing engine are { x }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}; wherein the private data { x₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bObtaining input data X through random dispersion processing; each computing node acquires sharable random set based on private data to be shared respectivelyBit value { c₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}; according to the multi-party computing instruction generated by executing the computing task of transmitting the input data X carelessly by using four computing nodes, the computing engine executes the following steps:

enabling the first computing node and the second computing node to share a first random number r₁₂And r'₁₂(ii) a The first computing node and the third computing node share a second random number r'_1a(ii) a The first computing node and the fourth computing node share a second type of random number r_1b(ii) a Enabling the second computing node and the third computing node to share a second type random number r_2a(ii) a The second computing node and the fourth computing node share a second random number r'_2b(ii) a Enabling the third computing node and the fourth computing node to share a first type of random number r_abAnd r'_ab(ii) a Enabling each computing node to perform mathematical computation with a first type of random number on whether private data is transmitted or not by using the respectively configured bit value, and performing mathematical computation with a second type of random number on whether the first type of random number is transmitted or not by using the respectively configured bit value to obtain intermediate data and an intermediate random number; the first computing node and the second computing node respectively perform replacement operation of intermediate data and intermediate random numbers with the third computing node and the fourth computing node; and enabling each computing node to execute mathematical computation including the cancellation of the second random number, and obtaining the respective held computation result.

In certain embodiments of the first aspect of the present application, the computation engine generates no more than 4 x 4 permuted data-based data communications during execution of the computation task.

In certain embodiments of the first aspect of the present application, the computing engine generates data traffic of no more than 4n × 4 bits of data during execution of the computing task, where n is a range of values Z of private data and a shared random number_2n。

In certain embodiments of the first aspect of the present application, each computing node derives the shared random number based on the same random number generator.

In certain embodiments of the first aspect of the present application, the step of the compute engine obtaining multi-party compute instructions for the compute task includes: each computing node acquires the multi-party computing instruction and the computing role; and each computing node executes the multi-party computing instruction according to the respectively acquired computing role.

In certain embodiments of the first aspect of the present application, the step of the compute engine obtaining multi-party compute instructions for the compute task includes: and each computing node respectively acquires a corresponding locally executed computing instruction in the multi-party computing instruction.

In certain embodiments of the first aspect of the present application, the method further includes sending the computation results held by two of the four computation nodes to a data acquisition device, so that the data acquisition device generates a processing result corresponding to the computation task based on the obtained computation results.

A second aspect of the present application provides a computing engine comprising: the four computing nodes are used for cooperatively computing a multi-party computing instruction corresponding to a computing task; the computing task is used for carrying out data processing on input data;

the four computing nodes execute the multi-party computing method according to any one of the first aspect based on the obtained multi-party computing instruction and the obtained private data set; and each private data set is obtained by the input data based on a random decentralized processing mode corresponding to the computing task.

A third aspect of the present application provides a readable medium in a computing node, characterized in that at least one program is stored, which at least one program, when invoked, participates in performing a multi-party computing method as described in any of the first aspects.

As described above, the input data calculation method, calculation engine, and storage medium according to the present application have the following advantageous effects: the computing engine consisting of the four computing nodes and the multi-party computing method provided by the application utilize private data suitable for computing tasks to carry out local and inter-node interaction, effectively improve the data transmission quantity of the multi-party computing performed by the four computing nodes and reduce the computing complexity. The mode that the random numbers are shared among the computing nodes to participate in the computation is utilized, so that the computing results obtained by the computing nodes are not returned in a plain code mode, and the data security is guaranteed. In addition, the multi-party computing using the multi-party computing instruction described herein effectively reduces the amount of data transmitted between computing nodes.

Drawings

FIG. 1 is a schematic diagram illustrating a computing task of a loop processing operation using a tree structure according to the present application.

FIG. 2 is a schematic diagram of the computational task optimization process shown in FIG. 1.

FIG. 3 is a schematic diagram illustrating the task of computing the operations of extracting common factors according to the present application by using a tree structure.

FIG. 4 is a schematic diagram of the computational task optimization process shown in FIG. 3.

FIG. 5 is a schematic diagram illustrating the calculation task of the common expression extraction operation using a tree structure according to the present application.

FIG. 6 is a schematic diagram of the computational task optimization process shown in FIG. 5.

FIG. 7 is a schematic block diagram of a flow chart of the multi-party computing method of the present application.

Detailed Description

The following description of the embodiments of the present application is provided for illustrative purposes, and other advantages and capabilities of the present application will become apparent to those skilled in the art from the present disclosure.

Although the terms first, second, etc. may be used herein to describe various elements in some instances, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, a first computing node may be referred to as a second computing node, and similarly, a second computing node may be referred to as a first computing node, without departing from the scope of the various described embodiments, but they are not the same computing node unless the context clearly dictates otherwise.

Also, as used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context indicates otherwise. It will be further understood that the terms "comprises," "comprising," "includes" and/or "including," when used in this specification, specify the presence of stated features, steps, operations, elements, components, items, species, and/or groups, but do not preclude the presence, or addition of one or more other features, steps, operations, elements, components, species, and/or groups thereof. The terms "or" and/or "as used herein are to be construed as inclusive or meaning any one or any combination. Thus, "A, B or C" or "A, B and/or C" means "any of the following: a; b; c; a and B; a and C; b and C; A. b and C ". An exception to this definition will occur only when a combination of elements, functions, steps or operations are inherently mutually exclusive in some way.

In order to protect private data of internet enterprises and users, some methods employ encryption for data transmission to ensure that a computer device does not obtain the private data during data transmission, however, the encrypted data needs to be decrypted when the processing device performs data processing. This makes private data non-private on the processing device. In other modes, the data processing process using the private data adopts a data processing mode, such as a secret sharing mode, used by cryptography, in which multiple parties participate in computing, so that the processing device for processing the private data does not need to perform data processing using the decrypted private data. Although the problem of privacy of private data is effectively solved in this way, for a technician, the utilization of cryptography technology for data processing has a very high research and development threshold, which is not favorable for the purpose of using private data to develop services while ensuring that the private data is not leaked. Moreover, the computing engine for multi-party computing is limited by the number of the selected computing nodes, the computing complexity, the computing security and the like, so that the data processing mode for multi-party computing brings about the problems of large data volume, low computing efficiency and the like.

To this end, the present application provides a calculation method. In some examples, the computing method utilizes a compute engine cooperatively computed by four compute nodes to compute a compute task generated by a task management platform, wherein the compute task is used for data processing of input data.

The task management platform can be a single computer device, or a service system based on a cloud architecture, and the like. The single computer device may be an autonomously configured computer device that can execute the processing method, and may be located in a private computer room or a leased computer location in a public computer room. The Service system of the Cloud architecture comprises a Public Cloud (Public Cloud) Service end and a Private Cloud (Private Cloud) Service end, wherein the Public or Private Cloud Service end comprises Software-as-a-Service (SaaS), Platform-as-a-Service (PaaS), Infrastructure-as-a-Service (IaaS), and the like. The private cloud service end is used for example for an Aliskian cloud computing service platform, an Amazon cloud computing service platform, a Baidu cloud computing platform, a Tencent cloud computing platform and the like.

The task management platform may include a storage device, a processing device, a network interface device, and the like. In fact, according to the hardware device of the task management platform actually running the processing method, the above devices can be located on a single server, or located in multiple servers and cooperatively completed through data communication among the servers.

For this purpose, the interface device is connected to the processing device in a data-transmitting manner via a bus connection or via a communication network. To this end, the interface means include, but are not limited to, a network card, a mobile network access module, a bus interface connected to the processing means through a bus, and the like. The interface device is also communicatively connected to a computing node, wherein the computing node is selected by a processing device executing the processing method, and the computing node may be one or more. The computing node may be a physical computing device or a virtual device carried by a physical computing device. The interface device is in data communication with each of the computing nodes via at least one of the internet, a mobile network, and a local area network to send computing instructions for the secret computation to each of the computing nodes.

The storage device is used for storing at least one program which can execute the processing method. The storage device may be located on the same physical server as the processing device, or in a different physical server and delivers the program to the processing device running the program through the interface device of each server. The storage may include high speed random access memory and may also include non-volatile memory, such as one or more magnetic disk storage devices, flash memory devices, or other non-volatile solid state storage devices. In certain embodiments, the memory may also include memory that is remote from the one or more processors, such as network-attached memory accessed via RF circuitry or external ports and a communication network (not shown), which may be the internet, one or more intranets, Local Area Networks (LANs), wide area networks (WLANs), Storage Area Networks (SANs), etc., or a suitable combination thereof. The storage device also includes a memory controller that can control access to the memory by other components of the device, such as the CPU and peripheral interfaces. Among the software components stored in the storage device are an operating system, a communications module (or set of instructions), a text input module (or set of instructions), and an application (or set of instructions).

The processing device is operatively coupled with the storage device. More specifically, the processing device may execute programs stored in the memory and/or the non-volatile storage to perform operations in the task platform. As such, the processing device may include one or more general purpose microprocessors, one or more application specific processors (ASICs), one or more field programmable logic arrays (FPGAs), or any combination thereof. The plurality of CPUs included in the processing device may be located in the same entity server or dispersed in a plurality of entity servers, and implement data communication by means of the interface device, so as to cooperatively execute a multiparty computation instruction for converting a computation task into multiparty computation for four computation nodes, and provide the multiparty computation instruction for each computation node for execution.

The task management platform is used for acquiring a computing task and converting the computing task into a multi-party computing instruction. Wherein the input data is data required for performing a computing task, and includes but is not limited to: at least one of data generated by the task management platform itself, data input by a user, data from a data source, or data from other communicable computer devices such as the internet. In some examples, the input data is a private data. Wherein the private data refers to data stored in digitized form and having undesirable compromised attributes, including but not limited to: the information processing method comprises the following steps of personal/enterprise identity information, personal/enterprise account information, personal appearance characteristic information, personal/enterprise consumption information (such as bills), information (such as moving routes, browsing duration and the like) generated by a person/enterprise due to software using behaviors, evaluation information collected by the enterprise and having business value, information obtained by analyzing the enterprise according to at least the information, and the like. The digitized form of the storage is exemplified here as data stored in a computer-readable storage medium with private data labels and/or rights, the properties of which it is not desired to reveal being represented in the labels and/or rights set. Wherein the tag includes, but is not limited to, a flag bit (e.g., boolean value, etc.) marked in the database and corresponding to data stored in the database. The rights include, but are not limited to: the right to read and write data, the right to obtain the private data in the clear, etc.

The computing task is used for processing the input data. In some examples, the input data is a private data; the technical personnel stores in advance a program containing business logic for processing the private data in the task management platform, wherein the business logic describes the processing process of the private data through a computer program language, and the processing process can contain one or more computing tasks. The business logic refers to a process that a technician performs data processing on private data by using one or more computing tasks and obtains the private data according to a natural law. For example, one business logic comprises: and (3) confirming the evaluation flow of the repayment capacity of the user A by using the bank deposit amount, the bank loan amount, the bank repayment history and the like of the user A in the banks B1 and B2. As another example, a business logic comprises: and providing a distance and route information distance prompting flow between the P1 and the P2 to the terminal equipment held by the user P1 by utilizing the current position information of the users P1 and P2.

The computational tasks are divided according to the logical order between input data and output data in the business logic. For example, the business logic includes processing logic that multiplies input data a1 and a2 and obtains a processing result B1, and processing logic that compares the processing result B1 as further input data A3 and input data a4 and obtains a processing result B2; among them, the calculation tasks may be divided into a calculation task of performing a multiplication calculation using the input data a1 and a2, and a calculation task of performing a comparison calculation using the input data A3 and a 4.

It should be noted that the above examples are merely examples, and more complex computing tasks may be included in the business logic according to actual design requirements, and it should be understood that the complex computing tasks may be performed by one or more computing units. Wherein the computing unit includes but is not limited to: digital computation processes such as addition, subtraction, multiplication and division, and logical computation of AND, OR and NOT, etc.

To this end, in some examples, the computing task includes: program modules obtained by a computer programming language editing interface. For example, the task management platform provides an editing interface for obtaining a computer language program describing business logic; technical personnel design business logic according to a program tool package (such as API and the like) provided by an editing interface and submit the business logic to the task management platform, and the task management platform decomposes a program into a plurality of computing tasks. In still other examples, the task management platform provides an editing interface for obtaining data source information of input data and processing modes of the input data. For example, the task management platform provides an editing interface including an input edit box, a selection edit box, and the like; and a technician designs business logic according to the input prompt provided by the editing interface and submits the business logic to the task management platform, and the task management platform decomposes the program generated based on the acquired editing interface into a plurality of calculation tasks. In other examples, the computing task is to convert the program described in the computer program language mentioned in the foregoing examples into a process described by a computing formula. For example, the processes may be described by a computer programming language or using source code syntax structures. The source Syntax structure is, for example, an Abstract Syntax Tree (AST). For example, please refer to fig. 1, which is a schematic diagram illustrating a computation task of a loop processing operation using a tree structure; the calculation task of the loop processing operation is described as a tree structure including a processing result obtained by multiplication. The task management platform can optimize the tree structure shown in fig. 1 according to the multi-party processing method provided by the present application, for example, please refer to fig. 2, which is a schematic diagram of the computing task optimization process shown in fig. 1; according to the multiparty processing method provided by the application, the calculation tasks corresponding to the circular processing operation are optimized into the calculation tasks for executing the circular processing operation by utilizing matrix multiplication, and the calculation instruction is generated according to the optimized calculation tasks.

Similarly, for another example, please refer to fig. 3, which is a schematic diagram illustrating a computing task of factoring operations using a tree structure; the calculation task of extracting common factor operation is described as a tree structure which obtains a processing result in a mode of cascade addition calculation and multiplication calculation. Please refer to fig. 4, which shows a schematic diagram of the calculation task optimization process shown in fig. 3; according to the multi-party processing method provided by the application, the calculation tasks corresponding to the common factor extraction operation are optimized and processed into calculation tasks of each calculation result cascade and multiplication calculation obtained through addition calculation, and calculation instructions are generated according to the optimized calculation tasks.

For another example, please refer to fig. 5, which is a schematic diagram illustrating a calculation task of a common expression extraction operation by using a tree structure; the calculation task of the common expression extraction operation is described as a tree structure which obtains a processing result in a mode of cascade addition calculation and multiplication calculation. Please refer to fig. 6, which is a schematic diagram illustrating the calculation task optimization process shown in fig. 5; according to the multiparty processing method provided by the application, the calculation task corresponding to the common expression extraction operation is optimized into the calculation task calculated through the matrix addition, and the multiparty calculation instruction is generated according to the optimized calculation task.

The task management platform converts the computing tasks into multi-party computing instructions cooperatively executed by the computing nodes in the computing engine according to the number of the computing nodes in the computing engine provided by the application. The computing engine provided by the application comprises four computing nodes.

In other examples, the computing method utilizes four computing nodes to cooperatively compute the computing task and the computing role directly provided by the terminal device, and according to the computing role, the corresponding computing node converts the computing task into a multi-party computing instruction and executes the computing method. The terminal device may be a computer device operated by a user, such as a personal computer. For example, the terminal device directly sends the calculation tasks to be calculated by multiple parties, the calculation roles in the multiple parties, and other contents to the four designated calculation nodes, and the terminal device also can send the calculation tasks together with the calculation roles to the data acquisition device for returning the calculation results. And each computing node translates the received computing task based on the multi-party computing protocol to obtain a multi-party computing instruction, and executes the computing method by executing the multi-party computing instruction. The computing task is the same as or similar to the computing task obtained by the task management platform, and will not be repeated here.

Here, the four compute nodes that make up the compute engine may be fixedly configured. Or the four computing nodes are selected based on the task management platform based on a selection rule; wherein, the selection rule includes attribute information of the computing node. Wherein, the attribute information of the computing node can be stored in a configuration file (or a log file, etc.) in the task management platform. Alternatively, the attribute information may be maintained and dynamically updated by the task management platform, including but not limited to: device information of each computing node, device provider information of an entity server where each computing node is located, and the like. The device information may be, for example, device information (e.g., an IP address, a MAC address, etc.) of an entity device, or device information (e.g., a virtual device ID, etc.) of a virtual device.

In terms of a multi-party computing manner, each computing node may configure a corresponding execution program or processing chip according to the multi-party computing performed on each computing node in advance. In terms of device configuration of a computing node, the computing node is a single computer device, or a physical device or a virtual device used in a cloud architecture-based service system. The single computer device may be an autonomously configured computer device that can execute the computing method, and may be located in a private computer room or a leased computer location in a public computer room. For example, by a data source as a compute node (or one of the compute nodes); the compute nodes may also be located on the side of a task management platform, e.g., the task management platform is a compute node (or one of the compute nodes). Therefore, the form and the set geographic position of the entity or the virtual equipment of the computing node are not limited. For example, the compute nodes may be located on different virtual devices of the same physical server and managed separately by administrative authority. The service system of the cloud architecture comprises a public cloud service end and a private cloud service end, wherein the public or private cloud service end comprises SaaS, PaaS, IaaS and the like. The private cloud service end comprises an Array cloud computing service platform, an Amazon cloud computing service platform, a Baidu cloud computing platform, a Tencent cloud computing platform and the like. The virtual device may be one of devices in which an entity server virtualizes a single stand-alone device into multiple logical devices through a virtualization technology, and the logical devices are used by multiple user processes simultaneously.

The computing nodes may include storage devices, processing devices, network interface devices, and the like. In fact, depending on the hardware devices of the computing method actually operated by the computing node, the above devices may be located on a single server, or located in multiple servers and perform computing instructions executed by a single computing node through data communication between the servers.

Please refer to fig. 7, which is a block diagram illustrating a flow chart of a multi-party computing method according to the present application. The multi-party computing method is cooperatively executed by four computing nodes in the computing engine.

In step S110, the computing engine obtains a multi-party computing instruction corresponding to the computing task, and obtains a private data set.

The multi-party computing instruction is designed based on a multi-party computing mode cooperatively executed by four computing nodes to execute a computing task. The task management platform converts the calculation tasks into the multi-party calculation instruction in advance according to a pre-established multi-party calculation protocol corresponding to each calculation task, and sends the multi-party calculation instruction to the calculation engine. The multi-party computing protocol is a process of indicating and scheduling each computing node in a computing engine to execute multi-party computing of a corresponding computing task, and includes but is not limited to: the method comprises a multi-party computation execution process for describing computation tasks of mathematical computation such as addition, subtraction, multiplication or division, a multi-party computation execution process for describing computation tasks of logical computation such as logical sum, or, not, exclusive or, comparison and the like, a multi-party computation execution process for describing secret transmission and the like.

The multi-party computing instructions include: the instructions for instructing four computing nodes in the computing engine to perform local computing, the instructions for performing data interaction between the computing nodes, the instructions for acquiring input data, the instructions for generating random numbers and the like are used for executing computing tasks in a multi-party computing manner. The multi-party computing instructions may also include instructions that instruct the computing nodes to perform computing roles for local computing and data interaction. The multi-party computing instructions may be described by a computer program language or by a machine language.

According to the foregoing examples of generating multi-party computing instructions, in one example, the multi-party computing instructions are directly from the task management platform. In another example, the multi-party computing instructions are generated based on the retrieved computing tasks.

In some examples, each computing node of the computing engine obtains a complete multi-party computing instruction corresponding to the computing task, that is, obtains a computing instruction including an execution of each computing node, and to this end, in order to make each computing node execute cooperatively, the steps include each computing node obtaining the multi-party computing instruction and a computing role; and each computing node executes the multi-party computing instruction according to the respectively acquired computing role. The computing roles are used for marking computing nodes which execute local computing in the multi-party computing instruction, marking a data sending party and a data receiving party when interaction between the computing nodes is executed in the multi-party computing instruction, and the like.

In still other examples, each computing node of the computing engine respectively obtains a corresponding locally executed computing instruction of the multi-party computing instructions. The computing instruction of the local execution instruction includes an instruction for executing local computing, an instruction for issuing locally stored data to perform data interaction, an instruction for storing received data locally to perform data interaction, an instruction for acquiring processed input data, an instruction for generating a random number, and the like. For example, the multi-party computing instruction comprises the computing node S1 executing the random number r generation₁₂Instruction P1, the computing node Sa performs the generation of the random number r_abAnd the calculation node S1 acquires the command P1, and the calculation node Sa acquires the command Pa.

In order to execute the calculation task, each calculation node in the calculation engine also acquires a private data set. The private data set includes private data obtained by performing random dispersion processing on all input data required by the computing task, for example, the computing task needs two input data X and Y, and the private data set obtained by each computing node includes { xi, yj }, where xi and yj are private data obtained by performing random dispersion processing on X and Y, respectively. Here, the private data corresponding to X in the private data set may be plural, but should not be so much as to obtain the input data X through the recovery operation, and similarly, the input data Y may be included, which is not described in detail herein.

Here, the compute engine may obtain input data from one or more data sources, depending on the data source from which the input data is in the compute task. According to a computing task containing private data or non-private data of input data, the corresponding computing engine also acquires the non-private data serving as the input data; and the multi-party computing instruction is determined based on the non-private data. In other words, the multi-party compute instruction does not necessarily use all of the compute nodes in the compute engine. The corresponding calculation instruction can be set according to whether the input data is private data or non-private data. In some specific examples, the input data involved in the computation task is non-private data, and the corresponding multi-party computation instruction instructs one computation node to execute each computation instruction. In yet other specific examples, the input data involved in the computing task includes private data and non-private data, and the corresponding multi-party computing instruction includes a computing instruction that optimizes multi-party computing for the non-private data. For example, the input data includes private data A1 and non-private data A2, the compute task includes computing the product of A1 and A2, the multi-party compute instruction includes an instruction for compute node S1 to compute a1 × A2, and an instruction for compute node S2 to compute a2 × A2; wherein a1 and a2 are private data obtained after A1 is subjected to random dispersion processing. In still other specific examples, the input data includes private data a1 and A3, the computation task includes computing a product of a1 and A3, the multi-party computation instruction includes an instruction for computing a11 × a31 by the computation node S1, an instruction for computing a12 × a32 by the computation node S2, an instruction for computing a13 × a33 by the computation node Sa, an instruction for computing a14 × a34 by the computation node S1 by Sa for permuting the data, an instruction for permuting the data by the computation node S2 by Sb, an instruction for computing by each computation node based on the permuted data and the locally computed data, and so on; wherein, a11 and a12, and a13 and a14 are private data obtained by randomly dispersing the input data A1; a31 and a32, and a33 and a34 are private data obtained by randomly dispersing the input data A3, respectively. As can be seen from the above examples, the multi-party computing instruction is determined according to the non-private data included in the input data in the computing task.

In some examples, the task management platform sends instruction information including a private data distribution mode to a corresponding data source according to a computing task in order to meet the privacy requirement of the data source on the input data. The task management platform requests a corresponding data source to perform random dispersion processing on input data according to the calculation requirement of a private data group in a multi-party calculation instruction corresponding to the calculation task, and the data source distributes each private data after random dispersion to each calculation node in the calculation engine according to the provided distribution mode. In still other examples, the input data for executing the computing task has the same random decentralized processing manner, and the task management platform may provide the device information of each computing node and the number of the corresponding private data group according to a data allocation rule agreed with each data source in advance, so that each processed private data is allocated by the data source according to the number. In other examples, the private data set may also be obtained by each compute node in the compute engine requesting directly from a data source. For example, each computing node in the computing engine sends a data request including the acquisition of the corresponding private data in the private data group to the corresponding data source according to the data source provided by the acquired multi-party computing instruction, where the data request includes the number of the private data group set by the data source based on each computing node in the computing engine, and thus each computing node obtains the private data group capable of performing multi-party computing. In still other examples, the input data may be represented by intermediate data generated by the computing nodes during execution of the computing instructions, for example, in a multi-party computing instruction comprising a hybrid computing in which one computing node randomly disperses the intermediate data into private data according to the computing instruction, distributes the private data to another computing node or nodes, and so on.

Wherein the input data may be integer type data or floating point type data. The data source can directly carry out random dispersion processing on the integer type data. For the floating point type data, the data source carries out binarization processing on the floating point type data, and then carries out random dispersion processing, so that a plurality of private data are obtained. Examples of the binarization process include IEEE 754. For example, the data source provides 125.5 as input data, which is represented in binary 1111101.1, with the scientific counts written in binary as: 1.111101 ^ 2^6, E ^ E +127 ^ 133, i.e. the binary format of the stage code 133 of E is 10000101, so the 32-bit binary floating point number of 125.5 is 01000010111110100000000000000000. Where the first bit, 0, represents the numeric sign, thereby converting 125.5 to a 32-bit binary number 01000010111110100000000000000000 and subjecting the 32-bit binary number to a random dispersion process. When a plurality of input data for data calculation in the calculation task include floating point type data, the input data can be unified in a manner of converting floating point numbers into binary format integers, and then calculation is executed.

Here, the random dispersion processing is to randomly generate a plurality of private data [ xj ] from the input data, where the private data [ xj ] can obtain corresponding input data through recoverable mathematical computation. On the basis, the private data set is obtained by input data based on a random decentralized processing mode required by the computation engine to execute multi-party computation; and the number of private data [ xj ] is preset based on the number of multi-party computing instructions and/or computing nodes executed by the compute engine. For example, the addition calculation in the calculation task is configured to be performed by two calculation nodes, and the corresponding input data is dispersed into first private data generated randomly and second private data obtained based on the first private data, wherein the first private data and the second private data can be restored into the input data, and the two private data are distributed to different calculation nodes for calculation. For another example, the computation task includes multiplication of two private input data, the two input data to be processed are respectively randomly dispersed into four sets of private data, and each set of private data is used for being allocated to one computation node to obtain a private data set of each computation node.

In some specific examples, the random dispersion processing manner includes: at least one private data is randomly generated, and the input data is subjected to decentralized processing according to the generated private data. Here, in some more specific examples, the random dispersion processing manner may randomly generate at least one secret data based on the number of computing nodes performing the computation. For example, the computation task includes addition computation, and if the number of computation nodes performing the addition computation is two, one private data a1 is randomly generated, and the input data is subjected to dispersion processing according to the private data a1, so that the private data a1 and a2 are obtained. In still more particular examples, the random decentralized processing may randomly generate a plurality of private data based on various computations used to orchestrate the computing task. For example, the computing task includes addition computation of input data a1 and a2 and multiplication computation of input data a2 and A3, wherein the addition computation is performed by two computing nodes, and the multiplication computation is instructed by four computing nodes, so that all input data can be randomly dispersed into four private data in order to reduce the number of interactions with a data source, and the corresponding private data is extracted by each computing node according to the executed instructions. For example, two pieces of private data are randomly generated for each piece of input data, and four pieces of private data are obtained by performing dispersion processing on the corresponding pieces of input data according to the two pieces of private data. In still more specific examples, unlike the foregoing examples, the random dispersion processing may be configured to randomly generate one piece of private data based on various computations used for the overall computing task, randomly disperse the input data into two pieces of private data according to the private data, distribute the two pieces of private data to different computing nodes, and send the obtained private data to other computing nodes by each computing node according to the executed computation instruction, or send the received private data to other computing nodes after being redispersed.

Based on the above description, the following are some examples of the random dispersion manner: in some specific examples, the random scatter processing of the input data includes a scatter processing for numerical values. The random dispersion treatment mode comprises the following steps: randomly generating two private data x₁And x'₁Based on the private data x₁And x'₁Scatter input data X into { X₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_b}; wherein x is₂＝X-x₁＝x_a，x₁＝x_b，x'₂＝X-x'₁＝x'_b，x'₁＝x'_a(ii) a The private data corresponding to the input data X in the private data set acquired by each computing node are respectively { X }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}. Multiplication of two numbers by a computational taskAnd one of the input data is 7 as an example, the input data 7 is dispersed into: the private data comprises {2,5} and {3,4 }; where 2 and 3 are randomly generated, and the secret data allocated to each computing node is {2}, {5}, {3}, and {4}, respectively. It should be noted that, in this example, only one of the input data is taken as an example, and the example is not limited to only one input data being subjected to the random dispersion processing in the calculation task of multiplying two numbers.

It should also be noted that the random processing may be performed in a manner that data bits n are constrained, such as randomly generated x₁And x'₁Are all limited to 2ⁿWherein n represents x₁And x'₁The number of binary bits.

In other specific examples, the input data comprises a bit value of C; the random dispersion processing mode aiming at the bit value comprises the following steps: randomly generating private data c of two bits₁And c'₁Based on said private data c₁And c'₁The input data C is dispersed into private data C expressed in bits₁,c'₁,c₂,c'₂,c_a,c'_a,c_b,c'_b}; wherein the content of the first and second substances,

c₁＝c_b，

c'₁＝c'_a(ii) a The private data corresponding to the input data C in the private data set acquired by each computing node are respectively { C }₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}. Taking the example that the computation task includes input data C as a bit value 1, the input data 1 is randomly decomposed into 0 and 1, four private data {0,1,1,0} are obtained according to the above formula, and the private data allocated to each computation node are {0,1}, {1,0}, {1,0}, and {0,1}, respectively.

In the above examples, the input data may be randomly dispersed in a manner not only selected but also combined according to the calculation task. Each computing node in the computing engine obtains private data of each input data from at least one data source and forms a private data set for executing the multi-party computing instruction so as to execute the multi-party computing instruction.

In addition, with the input data comprising private data a1 and A3, the computing task comprises an example of computing the product of a1 and A3 and generalizes to other computing tasks, in order to perform online multi-party computation on private data generated by the private data using four computing nodes, each computing node performs local computation using a shared random number to obtain intermediate data or computation results that can be cancelled, thereby ensuring that data transmitted between computing nodes, between computing nodes and other devices cannot be compromised. To this end, each computing node is provided with a random number generator that generates the random number. For example, according to the random numbers shared by the computing nodes, a random number generator for generating the shared random numbers according to the same random number generation rule is configured to each computing node through a multi-party computing instruction. For example, according to the multi-party computing instruction generated by the computing task, the computing nodes S1 and S2 share the random number r₁₂Then the random number generators configured in the computing nodes S1 and S2 share the same random number generation rule, thereby effectively avoiding the pair of random numbers r between the computing nodes S1 and S2₁₂The communication operation of (1).

In step S120, according to the multi-party calculation instruction, at least some of the calculation nodes in the calculation engine respectively perform local calculation on the respective acquired private data sets, and/or interact with intermediate data generated by the local calculation, so as to obtain calculation results respectively held by the calculation nodes.

According to the computing task, the multi-party computing instruction can instruct part of the computing nodes to only execute local computing and obtain a computing result. In some examples, the multi-party computing instructions include instructions generated based on computations that are homomorphic in a computing task; and according to the multi-party calculation instruction, the calculation nodes in the calculation engine execute local calculation and obtain corresponding calculation results. Wherein, the homomorphism representation can have a closed operation with a binding law, such as addition calculation and the like. In performing the add computations using the compute engine, the multi-party compute instruction may instruct both compute nodes to perform the add computations on the input data A1 and A2 and obtain the respective computed results. The data acquisition device may obtain the processing result of a1+ a2 by acquiring the calculation results of the two calculation nodes.

In still other examples, the multi-party computation instructions include instructions instructing the computing nodes to perform local computation on the respective acquired private data groups, and instructions to interact intermediate data generated by the local computation. In some specific examples, the multi-party computing instruction may correspond to each computation involved in the computing task. In some specific examples, the multi-party computing instructions include instructions configured based on an associative relationship between multiple computations in a computing task. Wherein the association between the plurality of computations includes but is not limited to: calculating priority relation, calculating homomorphism, calculating synchronicity, calculating required random decentralized processing mode of input data and the like. According to the incidence relation, the task management platform or the computing engine optimizes local computing and data interaction of each computing node, so that each computing node executes a local computing instruction according to the optimized multi-party computing instruction, and executes a data interaction instruction of the computing node. For example, the calculation task includes (X + Y) × Z, and the multi-party calculation instruction includes: the instruction instructs two computing nodes to execute local computation to obtain an instruction corresponding to (X + Y) multi-party computation, the instruction instructs the two computing nodes to take the computing results of the respective supported corresponding (X + Y) multi-party computation as intermediate data and to perform random decentralized processing, the instruction instructs four computing nodes to execute the instruction corresponding to (X + Y) xZ multi-party computation, and the like. For another example, the computation task includes the highest bit of the extraction (X-Y), and the multi-party computation instruction includes: the instruction for instructing two computing nodes to execute local computation to obtain corresponding (X-Y) multi-party computation, the instruction for instructing the two computing nodes to take the computing results of the respective supported corresponding (X-Y) multi-party computation as intermediate data and to perform random decentralized processing, the instruction for instructing four computing nodes to execute multi-party computation based on the computing result execution bit extraction, and the like.

After the computing engine obtains the computing result corresponding to the computing task, the data acquisition device uses the computing result held by the part of the computing nodes selected from the four computing nodes to generate a processing result; and the processing result is the processing result of the input data processed by the computing task.

Here, the computation engine obtains the computation results held by the computation nodes by executing the multi-party computation instruction, where the computation result held by each computation node may be one or more. For example, each compute node holds two compute results. And the data acquisition equipment of the computing task selects computing results held by part of the computing nodes from the four computing nodes executing the computing task according to the computing roles of the computing nodes, and executes a computing instruction for generating the processing result by using the obtained computing results, thereby completing the computing task containing the input data and obtaining the corresponding processing result. For another example, the number of the calculation results held by each of the calculation nodes is two, the data acquisition device selects two calculation nodes from the four calculation nodes according to the calculation roles of the calculation nodes and acquires all the calculation results held by the calculation nodes, and then calculates the four calculation results to obtain the processing results corresponding to the calculation tasks. With the processing method in the above example, the number of processing results obtained by the data obtaining device is two, and if the two processing results are the same, the data obtaining device may determine that the calculation task executed by the calculation engine is correct, otherwise, the calculation task is incorrect. Therefore, the method for extracting the calculation result by adopting the two-out-of-four mode also has the function of verifying the correctness of the processing result.

Here, the data acquisition device may be a provider of input data, such as a data source, according to the design requirements of the actual computing task, thereby avoiding the input data from being leaked; the data acquisition device may also be a terminal device that generates computational tasks, such as a computer device used by a user to input programs; the data acquisition device also uses the processing result of the computing task as a new computing task execution device of input data, such as a task management platform or other computer devices.

To this end, the multi-party computing instruction generated according to the multi-party computing protocol describes a multi-party computing process which can provide a two-out-of-four multi-party computing manner.

In some examples, the calculation task includes a calculation task of performing mathematical calculation on two input data, for example, a calculation task of summarizing a sum of two input data is included in a statistical algorithm. For example, an evaluation algorithm constructed based on input data includes a calculation task of multiplying a weight by the input data.

Here, the step S120 includes: and enabling the four computing nodes to execute local mathematical computation based on the acquired private data set, and enabling the four computing nodes to execute local computation by using the random numbers and obtain respectively held computing results by using data interaction of primary replacement data. Wherein the data manipulation of the permuted data represents the interchange of intermediate data by two compute nodes.

In some specific examples, the computing task includes a multiplication computing task of two input data, and the private data sets obtained by each computing node are { x } respectively₁,y₁}，{x₂,y₂}，{x_a,y_a}，{x_b,y_bIn which x₁＝x_a＝X-x₂And x₂＝x_bAnd y is₁＝y_a＝Y-y₂And y is₂＝y_bWherein, X and Y are two input data to be subjected to multiplication calculation; each computing node respectively carries out local computation based on multiplication to obtain intermediate data, acquires the intermediate data of the other side in a replacement interactive mode, and obtains computing results respectively held by each computing node based on the locally generated intermediate data and the intermediate data obtained by replacement.

In other specific examples, the four computing nodes perform local computation by using pairwise shared random numbers and the respective acquired private data to generate intermediate data, and perform data interaction for replacing the intermediate data between the four computing nodes; and the four computing nodes obtain respectively held computing results based on the interacted intermediate data.

Wherein, a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine are used for sequentially obtaining a private data set { x }₁,x'₁,y₁,y'₁}, private data set { x₂,x'₂,y₂,y'₂}, private data set { x_a,x'_a,y_a,y'_aAnd a private data set { x }_b,x'_b,y_b,y'_b}; wherein, { x₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bThe data X is obtained by random decentralized processing of input data, y₁,y'₁,y₂,y'₂,y_a,y'_a,y_b,y'_bThe data Y is obtained by performing random dispersion processing on the input data Y. Wherein each private data may satisfy the following exemplary random dispersion rule: x is the number of₂＝X-x₁＝x_a，x₁＝x_b，x'₂＝X-x'₁＝x'_b，”

x₁＝x_a。

After obtaining the private data group, each computing node performs the following steps to obtain the computing result held by each computing node when performing data interaction of replacing data once:

in step 121, the first computing node and the second computing node are made to share a random number r₁₂And r'₁₂And having said third and fourth computing nodes share a random number r_abAnd r'_ab. The data security of the computing node can be improved by using the shared random number. In order to reduce the data communication of each computing node to the shared random number, each random number can be generated when generating a multi-party computing instruction, or the multi-party computing instruction comprises a random number generator (also called as seed) for generating the shared random number according to the same random number generation rule, so that the first computing node and the second computing node obtain the same random number r₁₂And r'₁₂And the third computing node and the fourth computing node obtain the same random number r_abAnd r'_ab。

In step S122, the first computing node and the second computing node are respectively made to perform multiplication on the private data groups held by the first computing node and the second computing node and to cancel the random number r₁₂And r'₁₂So that the first computing node gets the intermediate data t₁And t'₁And the second computing node obtains the intermediate data t₂And t'₂。

Here, the first computing node is caused to execute a program based on the formula t₁＝x₁×y'₁-r₁₂And t'₁＝x'₁×y₁-r'₁₂And obtaining intermediate data t₁And t'₁(ii) a And having the second computing node proceed based on formula t₂＝x₂×y'₂+r₁₂And is based on the formula t'₂＝x'₂×y₂+r'₁₂Obtaining intermediate data t by local calculation₂And t'₂。

It should be noted that, the above-mentioned manner of making the first computing node subtract the random number and making the second computing node add the random number is only an example, and a manner of making the first computing node add the random number and making the second computing node subtract the random number may also be used.

In step S123, the third computing node and the fourth computing node are respectively made to perform multiplication and cancellation on the secret data sets held by the third computing node and the fourth computing node to obtain a random number r_abAnd r'_abSo that the first computing node gets the intermediate data t_aAnd t'_aAnd the second computing node obtains the intermediate data t_bAnd t'_b。

Here, the third computing node is caused to execute a program based on the formula t_a＝x_a×y'_a-r_abAnd is based on the formula t'_a＝x'_a×y_a-r'_abObtaining intermediate data t by local calculation_aAnd t'_a(ii) a And order theThe fourth computing node executes the program based on the formula t_b＝x_b×y'_b+r_abAnd is based on the formula t'_b＝x'_b×y_b+r'_abObtaining intermediate data t by local calculation_bAnd t'_b。

It should be noted that the above-mentioned method of making the third computing node subtract the random number and making the fourth computing node add the random number is only an example, and a method of making the third computing node add the random number and making the fourth computing node subtract the random number may also be used.

In step S124, let the first computing node and the third computing node replace respective one of the intermediate data, and the first computing node and the fourth computing node replace respective one of the intermediate data; the second and third compute nodes are caused to permute a respective one of the intermediate data, and the second and fourth compute nodes are caused to permute a respective one of the intermediate data.

Here, the intermediate data with the random number is replaced by using a data interaction relationship that is not constructed between the four computing nodes for the purpose of canceling the random number.

For example, let the first computing node intermediate data t₁Sending to a fourth compute node, and sending intermediate data t'₁Sending to a third computing node; let the second computing node intermediate data t₂Sending to a third compute node, and sending intermediate data t'₂Sending the data to a fourth computing node; let the third computing node send the intermediate data t_aSending to a second compute node, and sending intermediate data t'_aSending the data to a first computing node; and having the fourth computing node to convert the intermediate data t_bSending to the first compute node, and sending the intermediate data t'_bAnd sending the data to the second computing node.

It should be noted that the above replacement manner is set according to the multi-party multiplication calculation, and the replacement manner may be adaptively adjusted according to the multiplication local calculation executed by the actual calculation node, which is not illustrated herein.

Here, if private data and sharedThe random number being in the value range

For a computational task involving mathematical computation of two input data, the computational engine generates no more than 2 × data communications based on the permuted data during the performance of the computational task, and the computational engine generates no more than 2n × bits of data communications during the performance of the computational task, taking both input data as private data for example, the computational engine generates 2 × data communications based on the permuted data during the performance of the computational task, and the computational engine generates 2n × bits of data communications during the performance of the computational task.

In step S125, the computing nodes are respectively caused to perform local computation including addition using the intermediate data paired based on the permutation operation, so that each computing node obtains two computation results including the cancelable random number.

Here, the first compute node executes a data structure based on the formula z₁＝t₁+t_bAnd z'₁＝t'₁+t'_aObtaining a calculation result z₁And z'₁(ii) a The second computing node performs a calculation based on the formula z₂＝t₂+t_aAnd z'₂＝t'₂+t'_bObtaining a calculation result z₂And z'₂(ii) a Third computing node execution based on formula z_a＝t_a+t₂And z'_a＝t'_a+t'₁Obtaining a calculation result z_aAnd z'_a(ii) a The fourth computing node performs a function based on the formula z_b＝t_b+t₁And z'_b＝t'_b+t'₂Obtaining a calculation result z_bAnd z'_b。

The above calculation formulas are only examples. In still other examples, the mathematical calculations represented by some or all of the above equations may also be represented in the form of mathematical calculations based on, for example, binary numbers, depending on the way the input data is randomly scattered. And will not be described in detail herein.

The data acquisition device may select the first computing node and the third computing node, or the second computing node and the fourth computing node, according to the two computing nodes containing the cancelable random numbers determined by the computing protocol, cancel the random numbers generated by the computing nodes in an addition manner, and obtain two processing results corresponding to the XY multiplication computing tasks, or multiples of the processing results. The number of the processing results obtained according to the above example may be two, and if the two processing results are the same, the obtained processing result of the XY multiplication is indicated, and otherwise, a calculation error is indicated.

In other examples, the calculation task includes performing mathematical calculations on three input data, for example, in an algorithm for classifying the input data using a neural network, a calculation task for performing mathematical calculations on three input data with weights, input data, and biases, and the like. The step S120 includes: enabling the four computing nodes to obtain first computing results of respective held corresponding input data X and Y computing by utilizing data interaction of the first replacement data and taking the first computing results as intermediate data; enabling the four computing nodes to obtain the computing results held by the computing nodes by utilizing data interaction of the intermediate data for replacing the data for the second time; and having four of the compute nodes perform local computations based on the random numbers before permuting the data twice. Wherein the respective held calculation results are used to process the calculation tasks on the input data X, Y and Z.

In some specific examples, the computing task comprises a multiplication computing task of three input data X, Y and Z, and the private data sets obtained by each computing node are { x }₁,y₁,z₁}，{x₂,y₂,z₂}，{x_a,y_a,z_a}，{x_b,y_b,z_bIn which x₁＝x_a＝X-x₂And x₂＝x_b；y₁＝y_a＝Y-y₂And y is₂＝y_b(ii) a And z₁＝z_a＝Z-z₂And z is₂＝z_b(ii) a With reference to the multiplicative computation task for computing the input data X and Y provided in the foregoing example, the four computation nodes obtain the first computation result of the computation task for the corresponding input data X and Y by using one-time data interaction and use it as intermediate data; and then carrying out multi-party calculation based on one data interaction by using the intermediate data and private data corresponding to Z, thereby obtaining calculation results held by the intermediate data and private data, wherein the calculation results are used for generating processing results of calculation tasks containing three input data.

After obtaining the private data sets, each computing node performs the following steps to compute the multiplication task of the three input data. The private data set acquired by each computing node comprises: { x₁,y'₁,z₁}，{x₂,y'₂,z₂}，{x_a,y'_a,z_a}，{x_b,y'_b,z_b}; wherein x is₁＝x_a＝X-x₂And x₂＝x_b；y'₁＝y'_a＝Y-y'₂And y'₂＝y'_b(ii) a And z₁＝z_a＝Z-z₂And z is₂＝z_b。

In step S121', the first computing node and the second computing node are made to share a random number

r₁₂And r'₁₂And enabling the third computing node and the fourth computing node to share a random number

r_abAnd r'_ab. Here, of random numbersThe sharing may be the same as mentioned in the previous examples and will not be repeated here.

In step S122', four of the computing nodes are made to multiply private data relating to input data X and Y and to cancel random numbers, respectively

And

so that the first computing node gets the intermediate data t₁The second computing node obtains intermediate data t₂The third computing node obtains intermediate data t_aThe fourth computing node obtains intermediate data t_b。

Here, the first computing node is based on a formula

Obtaining intermediate data t by local calculation₁(ii) a Basing the second compute node on a formula

Obtaining intermediate data t by local calculation₂(ii) a Basing the third computing node on a formula

Obtaining intermediate data t by local calculation_a(ii) a And basing the fourth compute node on a formula

Obtaining intermediate data t by local calculation_b。

It should be noted that the above-mentioned adoption makes the first computing node pair to random number

Subtracting, and making the second computing node pair to random number

The addition is only exemplary, and the first computing node may also be used to generate a random number

Adding, and making the second computing node pair random number

The way of subtraction. The above-mentioned method uses the third computing node to calculate the random number

Subtracting, and making the fourth computing node pair to be random number

The addition method is also exemplified, and the third calculation node may be used to calculate the random number

Adding, and making the fourth computing node pair to random number

The way of subtraction.

In step S123', the first computing node and the third computing node are caused to replace the respective intermediate data; the second computing node and the third computing node are caused to permute the respective intermediate data.

Here, the first computing node combines the intermediate data result t with the intermediate data result t₁To a third computing node, and the third computing node transmits the intermediate data t_aSending the data to a first computing node; and the second computing node forming an intermediate data result t₂To a fourth computing node, and the fourth computing node transmits the intermediate data t_bAnd sending to the second computing node.

In step S124', each calculation node performs mathematical calculation of multiplication using each held intermediate data and private data corresponding to the input data Z so that the first calculation node obtains the intermediate data S₁The second computing node obtains intermediate data s₂The third computing node obtains intermediate data s_aThe fourth computing node obtains intermediate data s_b。

The first computing node is based on the formula s₁＝(t₁+t_a)×z₁Local computation of (2); the second computing node is based on the formula s₂＝(t₂+t_b)×z₂Local computation of (2); the third calculation node is based on the formula s_a＝(t_a+t₁)×z_aLocal computation of (2); the fourth calculation node is based on the formula s_b＝(t₂+t_b)×z_bLocal computation of (2).

In step S125', the first and second computing nodes respectively perform the processing on the intermediate data S held by the first and second computing nodes₁And s₂Performing multiplication and for cancelling the random number r₁₂And r'₁₂So that the first computing node obtains intermediate data h₁And h'₁And the second computing node obtains intermediate data h₂And h'₂(ii) a And enabling the third computing node and the fourth computing node to respectively carry out comparison on the intermediate data s held by the third computing node and the fourth computing node_aAnd s_bPerforming multiplication and for cancelling the random number r_abAnd r'_abSo that the third computation node gets the intermediate data h_aAnd h'_aAnd the fourth computing node obtains intermediate data h_bAnd h'_b；

Here, the first compute node is caused to execute a process based on the formula h₁＝s₁-r₁₂And h'₁＝s₁-r'₁₂And obtaining intermediate data h₁And h'₁(ii) a And having the second compute node proceed based on formula h₂＝s₂+r₁₂And is based on the formula h'₂＝s₂+r'₁₂Obtaining intermediate data h by local calculation₂And h'₂. Having a third computing node execute based on formula h_a＝s_a-r_abAnd h'_a＝s_a-r'_abAnd obtaining intermediate data h_aAnd h'_a(ii) a And having the fourth compute node proceed based on formula h_b＝s_b+r_abAnd is based on the formula h'_b＝s_b+r'_abObtaining intermediate data h by local calculation_bAnd h'_b。

In step S126', let the first computing node and the third computing node replace respective one of the intermediate data, and the first computing node and the fourth computing node replace respective one of the intermediate data; the second and third compute nodes are caused to permute a respective one of the intermediate data, and the second and fourth compute nodes are caused to permute a respective one of the intermediate data.

In this case, the first and fourth computing nodes are caused to replace the intermediate data h₁And h_b(ii) a Replacing the intermediate data h 'with the first compute node and the third compute node'₁And h'_a(ii) a The second computing node and the third computing node replace the intermediate data h₂And h_a(ii) a And replacing the intermediate data h 'with the second compute node and the fourth compute node'₂And h'_b。

In step S127', the respective computing nodes are caused to perform local computation including addition using the intermediate data paired based on the permutation operation, respectively, so that each computing node obtains two computation results including the cancelable random number.

Here, the first compute node executes a data structure based on the formula z₁＝h₁+h_bAnd z'₁＝h'₁+h'_aObtaining a calculation result z₁And z'₁(ii) a The second computing node performs a calculation based on the formula z₂＝h₂+h_aAnd z'₂＝h'₂+h'_bObtaining a calculation result z₂And z'₂(ii) a Third computing node execution based on formula z_a＝h_a+h₂And z'_a＝h'_a+h'₁Obtaining a calculation result z_aAnd z'_a(ii) a The fourth computing node performs a function based on the formula z_b＝h_b+h₁And z'_b＝h'_b+h'₂Obtaining a calculation result z_bAnd z'_b。

The data acquisition device may select the first computing node and the third computing node, or the second computing node and the fourth computing node, according to the two computing nodes containing the cancelable random numbers determined by the computing protocol, cancel the random numbers generated by the computing nodes in an addition manner, and obtain two processing results corresponding to XYZ multiplication computing tasks, or multiples of the processing results. The number of processing results obtained according to the above example may be two, and if the two processing results are the same, the obtained processing result of XYZ multiplication calculation is indicated, and otherwise, a calculation error is indicated.

Here, if the private data and the shared random number are in the value range

Internally random, each compute node sends out no more than n bits of data in the first permutation of the data, and in the second permutation of the dataTaking three input data as private data, the computing engine generates 3 × 4 times of data communication based on the replacement data during the execution of the computing task, and the computing engine generates 3n × bits of data communication based on the 3n × bits of data amount during the execution of the computing task.

In still other examples, depending on the design of the business logic, bit extraction may also be included in the computational task. Such as a computational task that extracts a bit according to a communication protocol. The step S120 includes: the four computing nodes obtain respective supporting computing results by utilizing data interaction of k rounds of 1-bit replacement data, wherein the computing results are used for extracting binary bits in the input data X; and k is the binary digit number to be extracted corresponding to the input data X in the calculation task. Here, the four computing nodes generate intermediate data (1 bit) including a random number capable of canceling 1 bit by performing bit computation locally, and obtain a computation result through data interaction of the intermediate data of k rounds.

In some specific examples, the multi-party computing tasks include computing tasks that extract binary bits in input data X; a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x }₁}, private data set { x₂}, private data set { x_aAnd a private data set { x }_b}; wherein, { x₁,x₂,x_a,x_bIs obtained by performing random dispersion processing on input data XAnd secret data represented in a binary system, wherein each secret data has the same binary digit k as the input data X. The step S120 includes the steps of:

in step S1211, the respective calculation nodes initialize bit values { c } for output₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}; and enabling the first computing node and the second computing node to share a random number r₁₂And b₁₂(ii) a And making the third computing node and the fourth computing node share a random number b_ab(ii) a The bit value of each bit of the initialization is 0, for example. The random number r₁₂、b₁₂And b_abIs a binary random number generated based on the number of extracted bits k. Wherein the random number sharing and generation is the same or similar to that mentioned in the previous examples and will not be repeated here.

In step S1212, let the first and second computing nodes use the random number r₁₂For respectively held private data x₁And x₂Logic processing is carried out on the low-k bits to obtain binary intermediate data u with low-k bits unified₁And u₂。

In this case, the first computing node is made to perform a formula-based process

Obtaining intermediate data u by local calculation₁(ii) a And provided to a third computing node; and having the second computing node proceed based on formula u₂＝x₂[1:k]∧r₁₂Obtaining intermediate data u by local calculation₂。

It should be noted that, according to actual design requirements, the logic processing of each computing node may be adjusted, and other computing nodes perform preprocessing for k rounds of circulation to obtain binary intermediate data u with low k bits unified₁And u₂The manner of (a) should be considered as a specific example adjusted by mathematical calculations based on the examples provided in the present application.

In step S1213, let the first compute node beIntermediate data u₁Sent to the third computing node and processed by the third computing node based on the formula u₁∧x_aAnd obtaining intermediate data u_a。

In step S1214, the following loop calculation is set based on the k value: each computing node is used for generating private data x₁With the random number b based on the sharing₁₂Or b_abAnd obtaining the intermediate data of the ith round; performing replacement processing on the intermediate data obtained in each turn, and assigning corresponding output bits; the first computing node and the third computing node perform replacement processing of intermediate data, and the second computing node and the fourth computing node perform replacement processing of intermediate data.

See, for example, the loop calculation set based on k values as described below using programming language conventions:

For(i＝1；i＜＝k-1；i＝i+1){

s1 calculation

And is prepared from t'₁And sending the data to the Sa.

S2 calculation

And is prepared from t'₂And sending the data to Sb.

Sa calculation

And is prepared from t'_aTo S1

Calculation of Sb

And is prepared from t'_bTo S2

S1 assignment

S2 assignment

Sa assignment

Value of Sb

}

Wherein S1, S2, Sa, and Sb denote a first computing node, a second computing node, a third computing node, and a fourth computing node, in that order.

In step S1215, each computing node performs logical computation on the k-th bit value of the private data held by each computing node by using the assigned output bit and the random number to obtain a computation result.

For example, the first compute node is based on a formula

Is locally calculated to obtain a calculated result c'₁(ii) a The second computing node performs formula-based

Obtaining a calculation result c 'through local calculation'₂(ii) a Third computing node performs formula-based

Obtaining a calculation result c by local calculation_a(ii) a The fourth computing node performs formula-based

Obtaining a calculation result c by local calculation_b。

It should be noted that the formula in the above example is related to the processing method of the k round, and can be adjusted according to the bit processing method of the actual k round.

In step S1216, the first compute node will compute result c'₁To a third computing node; the second computing node will compute result c'₂To a fourth computing node; the third computing node will compute the result c_aTo a second computing node; fourth meterThe calculation node calculates the result c_bProvided to the first compute node so that each compute node holds two compute results that are convenient for verifying the results of the process.

For example, the first compute node will compute result c'₁Is provided to a third computing node such that the computation result of the third computing node contains c_aAnd c'_aWherein, c'_a＝c'₁(ii) a The second computing node will compute result c'₂Is provided to the fourth computing node so that the computing result of the fourth computing node contains c_bAnd c'_bWherein, c'_b＝c'₂(ii) a The third computing node will compute the result c_aIs provided to the second computing node so that the result of the computation of the second computing node contains c₂And c'₂Wherein, c'₂＝c_a(ii) a The fourth computing node calculates the result c_bIs provided to the first computing node such that the computation result of the first computing node comprises c₁And c'₁Wherein, c'₁＝c_b。

The data acquisition device may select the calculation result of a pair of calculation nodes according to the pair of calculation nodes determined by the calculation protocol, offset the random number generated by the calculation node in a logical calculation manner, and obtain a processing result of the calculation task for extracting the kth bit of the input data X, or a multiple of the obtained processing result. The number of the obtained processing results can be two, if the two processing results are the same, the processing result is correct, otherwise, the calculation is wrong.

Here, each compute node produces no more than k +1 data communications; and each compute node produces data communications of no more than a 2k bit data volume. As can be seen from the data communication in step S1213, when each of the computing nodes performs data exchange of 1-bit permutation data in k rounds, each of the computing nodes sends k bits in total. In addition, the first computing node also generates one data communication of the data amount of k bits, so the first computing node generates k +1 data communication and 2k data communication in total. .

In some more specific examples, the rootAs described in the foregoing steps S1211-S1215, we share x in steps S1211-S1213 by letting S1 and Sb share₁[1:k]∧x₂[1:k]Half share to further optimize communication complexity. In this case, each compute node produces no more than 1.5 kbit data communications.

The multi-party computing instruction using bit extraction may be used for computing tasks including computing tasks that compare two input data. In some examples, the computing task comparing the two input data A1 and A3 is first converted into a computing task of computing (A1-A3) and a computing task of extracting the highest bit value in the computed result of the binary representation (A1-A3). Therefore, according to a multi-party calculation instruction generated by the converted calculation task, the calculation engine enables the four calculation nodes to execute local calculation and data interaction according to the multi-party calculation instruction set based on the two input data subtraction calculation tasks and the bit extraction calculation task, and the bit values held by the four calculation nodes are obtained. For example, the calculation engine performs subtraction calculation using partial calculation nodes according to a multiparty calculation instruction, obtains respective own subtraction calculation results, uses the respective own subtraction calculation results as private data for bit extraction calculation, and performs highest bit extraction using data exchanged once (k is 1) bit positions to obtain a calculation result of bit extraction. The calculation result of the bit extraction can be fed back to the data acquirer as a calculation result for obtaining the comparison result of a1 and A3.

In other examples, where the data in the comparison result is larger (or smaller) based on the computational task, the corresponding input data may be transmitted by an inadvertent transmission of the compute engine based on the compute engine obtaining the computed result for bit extraction representing the comparison result. Thereby avoiding the possibility of information leakage of the data acquirer and the calculation engine. The step S120 includes executing multiparty calculation instructions set based on the oblivious transfer protocol by using four calculation nodes and obtaining calculation results held by each.

The oblivious transfer protocol is a two-party communication protocol which can protect privacy and enable two communication parties to transmit messages in a selective fuzzification mode. Inadvertent transmission protocol is a basic protocol of cryptography that allows the recipient of a service to obtain certain messages entered by the sender of the service in an inadvertent manner, thus protecting the privacy of the recipient from the sender's knowledge.

In some specific examples, the utilizing four computing nodes to execute the multi-party computing instruction set based on the oblivious transfer protocol and obtain the respective held computing results includes: enabling the four computing nodes to determine weights for indicating transmission/non-transmission of corresponding private data, and obtaining respective held computing results by utilizing local computing and data interaction; wherein the calculation result comprises a result for indicating that the corresponding private data is transmitted or a result for indicating that the corresponding private data is not transmitted. For example, the calculation task includes a calculation task of inadvertently transmitting input data X, and the bit value { c of each calculation node is randomly initialized by using the input bit value c₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_bAnd allocating the data to each computing node; wherein the content of the first and second substances,

c₂＝c_a，c'₁＝c'_a，c'₂＝c'_b，c₁＝c_b. Taking the initialization bit value c as 1 as an example, the random bit value c allocated to the first computing node is based on the bit value c₁1 and c'₁When the bit value is 0, the bit value {0,1} assigned to the second calculation node, the bit value {0,0} assigned to the third calculation node, and the bit value {1,1} assigned to the fourth calculation node. And each computing node takes the obtained bit value as a weight, performs mathematical computation on the transmitted or non-transmitted private data by using local computation, and obtains respective held computation results by using data interaction.

And according to the quantity of the private data obtained by each computing node, each computing node obtains a corresponding quantity computing result which is used for indicating that the private data in the private data is transmitted or not transmitted. Take the example of each computing node obtaining two private data, wherein the input data X is randomly dispersed and processed into a plurality of private data { X }₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bIn which x₂＝X-x₁＝x_a，x₁＝x_b，x'₂＝X-x'₁＝x'_b，x'₁＝x'_a(ii) a The private data obtained by each computing node are { x }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}. The execution process of step S120 is as follows:

in step S1211', the first computing node and the second computing node are made to share a first type of random number r₁₂And r'₁₂(ii) a The first computing node and the third computing node share a second random number r'_1a(ii) a The first computing node and the fourth computing node share a second type of random number r_1b(ii) a Enabling the second computing node and the third computing node to share a second type random number r_2a(ii) a The second computing node and the fourth computing node share a second random number r'_2b(ii) a Enabling the third computing node and the fourth computing node to share a first type of random number r_abAnd r'_ab. Here, the sharing manner of each random number may be the same as or similar to the sharing manner described above, and will not be repeated here.

In step S1212', each computing node is enabled to perform mathematical computation with a first type of random number on whether to transmit the private data by using the configured bit value, and perform mathematical computation with a second type of random number on whether to transmit the first type of random number by using the configured bit value.

For example, the first compute node is based on the formula t₁＝x₁×c'₁-r₁₂、t'₁＝x'₁×c₁-r'₁₂Locally calculating to obtain intermediate data t carrying first-class random numbers₁And t'₁And based on formula e₁＝(1-2c'₁)×r₁₂+r_1aAnd e'₁＝(1-2c₁)×r'₁₂+r'_1aObtaining an intermediate random number e carrying a second type of random number by local calculation₁And e'₁. Similarly, the second compute node is based on the formula t₂＝x₂×c'₂-r₁₂And t'₂＝x'₂×c₂-r'₂Obtaining intermediate data t₂And t'₂Based on the formula e₂＝(1-2c'₂)×r₁₂+r_2aAnd e'₂＝(1-2c₂)×r'₁₂+r'_2aObtain an intermediate random number e₂And e'₂. The third calculation node is based on the formula t_a＝x_a×c'_a-r_abAnd t'_a＝x'_a×c_a-r'_abObtaining intermediate data t_aAnd t'_aBased on the formula e_a＝(1-2c'_a)×r_ab+r_2aAnd ea ═ (1-2ca) × rab '+ r1a' to yield the intermediate random number e_aAnd e'_a. The fourth calculation node is based on the formula t_b＝x_b×c'_b-r_abAnd t'_b＝x'_b×c_b-r'_abObtaining intermediate data t_bAnd t'_bBased on the formula e_a＝(1-2c'_a)×r_ab+r_2aAnd e'_a＝(1-2c_a)×r'_ab+r'_1aObtain an intermediate random number e_bAnd e'_b。

In step S1213', the first and second computation nodes are caused to perform a permutation operation of the intermediate data and the intermediate random number with the third and fourth computation nodes, respectively.

For example, let the first compute node and the third compute node permute { t'₁,e₁And { t'_a,e_aH, the first and fourth compute nodes replace { t }₁,e'₁And t_b,e'_b}; permuting { t 'of second compute node and third compute node'₂,e₂And t_a,e'_aAnd the second and fourth compute nodes permute { t }₂,e'₂And { t'_b,e_b}。

In step S1214', each computing node is caused to perform a mathematical computation including the cancellation of the second type random numbers, and obtain the respective computation results.

For example, let the first calculation be based on the formula y₁＝(1-2c'₁)t_b+c'₁x₁+e_a-r_1bAnd y'₁＝(1-2c₁)t'_a+c₁x'₁+e'_b-r'_1aObtaining a calculation result y₁And y'₁(ii) a Basing the second calculation on formula y₂＝(1-2c'₂)t_a+c'₂x₂+e_b-r_2aAnd y'₂＝(1-2c₂)t'_b+c₂x'₂+e'_a-r'_2bObtaining a calculation result y₂And y'₂(ii) a Basing the third calculation on formula y_a＝(1-2c'_a)t₂+c'_ax_a+e₁-r_2aAnd y'_a＝(1-2c_a)t'₁+c_ax'_a+e'₁-r'_1aObtaining a calculation result y_aAnd y'_a(ii) a Basing the fourth calculation on formula y_b＝(1-2c'_b)t₁+c'_bx_b+e₂-r_1bAnd y'_b＝(1-2c_b)t2'₁+c_bx'_b+e'₂-r'_2bObtaining a calculation result y_bAnd y'_b。

The data acquisition device may select the calculation result of a pair of calculation nodes according to the two calculation nodes determined by the calculation protocol, and cancel the first-type random number generated by the calculation node in a logical calculation manner, and obtain a processing result of a calculation task in which the input data X is unintentionally transmitted, or a multiple of the processing result. The number of the obtained processing results can be two, if the two processing results are the same, the processing result is correct, otherwise, the calculation is wrong.

It should be noted that the above formulas are only examples, and in fact, mathematical calculations and data interactions can be adjusted by adjusting actual weight setting rules or adjusting the signs of random numbers based on the above examples, and mathematical variants based on the above examples should be regarded as specific examples based on the technical idea of the present solution. And will not be described in detail herein.

Here, if the private data and the shared random number are in the value range Z_2nThe internal random results, then the amount of data sent out by each compute node when executing one time of permuting data does not exceed 2n, each compute node executes two times of permuting data operations, so that each compute node sends out no more than 4n bit data amounts when executing one time of oblivious transfer protocol for this purpose, the compute engine generates no more than 4 × 4 times of data communication based on permuting data during executing the compute task, and the compute engine generates no more than 4n × 4 bit data communication during executing the compute task.

Based on the above description, the computing engine and the multi-party computing method composed of four computing nodes provided by the present application use private data suitable for computing tasks to perform local and inter-node interaction, thereby implementing multi-party computing. The mode that the random numbers are shared among the computing nodes to participate in the computation is utilized, so that the computing results obtained by the computing nodes are not returned in a plain code mode, and the data security is guaranteed. In addition, the multi-party computing using the multi-party computing instruction described herein effectively reduces the amount of data transmitted between computing nodes.

In another embodiment of the present application, a computer-readable storage medium storing at least one program that participates in performing the multi-party computing method when invoked is also disclosed. Wherein the computer is any one of the aforementioned computing nodes. The multi-party calculation method is described with reference to fig. 7 and the related description related to fig. 7, and will not be described herein again. It should be noted that, through the above description of the embodiments, those skilled in the art can clearly understand that part or all of the present application can be implemented by software and combined with necessary general hardware platform. With this understanding, the storage medium stores at least one program that, when invoked, performs any of the navigation methods described above. With this understanding in mind, the technical solutions of the present application and/or portions thereof that contribute to the prior art may be embodied in the form of a software product that may include one or more machine-readable media having stored thereon machine-executable instructions that, when executed by one or more machines such as a computer, network of computers, or other electronic devices, may cause the one or more machines to perform operations in accordance with embodiments of the present application. For example, each step in the positioning method of the robot is performed. The machine-readable medium may include, but is not limited to, floppy diskettes, optical disks, CD-ROMs (compact disc-read only memories), magneto-optical disks, ROMs (read only memories), RAMs (random access memories), EPROMs (erasable programmable read only memories), EEPROMs (electrically erasable programmable read only memories), magnetic or optical cards, flash memory, or other type of media/machine-readable medium suitable for storing machine-executable instructions. The storage medium may be located in a server or a third-party server, for example, in an aristo service system. The application is operational with numerous general purpose or special purpose computing system environments or configurations. For example: mainframe computers, distributed computing environments that include any of the above systems or devices, and the like. The application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

The above embodiments are merely illustrative of the principles and utilities of the present application and are not intended to limit the application. Any person skilled in the art can modify or change the above-described embodiments without departing from the spirit and scope of the present application. Accordingly, it is intended that all equivalent modifications or changes which can be made by those skilled in the art without departing from the spirit and technical concepts disclosed in the present application shall be covered by the claims of the present application.

Claims

1. A computing method of input data, wherein a computation engine cooperatively computed by four computation nodes is used to compute a multi-party computation instruction corresponding to a computation task, wherein the computation task is used to perform data processing on the input data, the computing method comprising:

the calculation engine acquires the multi-party calculation instruction and acquires a private data set; each private data set is obtained by the input data based on a random decentralized processing mode required by the computation engine to execute multi-party computation;

according to the multi-party calculation instruction, at least part of calculation nodes in the calculation engine respectively carry out local calculation on the private data groups acquired by the calculation nodes, and/or intermediate data generated by the local calculation are interacted, so that calculation results respectively held by the calculation nodes are obtained;

wherein, the calculation results held by part of the calculation nodes selected from the four calculation nodes are used for generating a processing result; wherein the processing result is a processing result of the computing task processing the input data.

2. The method of calculating input data according to claim 1, wherein the stochastic break-up processing comprises: at least one private data is randomly generated, and the input data is subjected to decentralized processing according to the generated private data.

3. The method of calculating input data according to claim 2, wherein the input data comprises a numerical value X; the random dispersion treatment mode comprises the following steps: randomly generating two private data x₁And x'₁Based on the private data x₁And x'₁Scatter input data X into { X₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_b}; wherein x is₂＝X-x₁＝x_a，x₁＝x_b，x'₂＝X-x'₁＝x'_b，x'₁＝x'_a(ii) a The private data corresponding to the input data X in the private data set acquired by each computing node are respectively { X }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}。

4. The method of calculating input data according to claim 2, wherein the input data contains a bit value C; the random dispersion treatment mode comprises the following steps: randomly generating private data c of two bits₁And c'₁Based on said private data c₁And c'₁The input data C is dispersed into private data C expressed in bits₁,c'₁,c₂,c'₂,c_a,c'_a,c_b,c'_b}; wherein the content of the first and second substances,

c₁＝c_b，

5. The method of computing input data according to claim 1, wherein the input data includes floating point type data; the private data is obtained by performing random dispersion processing on the binary floating point type data.

6. The input data calculation method according to claim 1, wherein the calculation engine further acquires non-private data as input data; the multi-party computing instruction is determined from the non-private data.

7. The input data calculation method according to claim 1, wherein the multi-party calculation instruction includes an instruction generated based on a calculation having homomorphism in a calculation task; and according to the multi-party calculation instruction, the calculation nodes in the calculation engine execute local calculation and obtain corresponding calculation results.

8. The method according to claim 1, wherein the multi-party computation instruction includes an instruction set based on an association relationship between a plurality of computations in a computation task.

9. The input data computing method of claim 1, wherein each computing node performs local computation using a shared random number to obtain intermediate data or computation results that can be cancelled; wherein each computing node is provided with a random number generator that generates the random number.

10. The input data computing method of claim 9, wherein the computing task comprises a mathematical computing task of two input data; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises the following steps: and enabling the four computing nodes to execute local computation by using the random numbers and obtain respectively held computing results by using data interaction of once replacement data.

11. The method of computing input data according to claim 10, wherein the computing task includes a multiplication computing task of two input data; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises the following steps:

a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x }₁,x'₁,y₁,y'₁}, private data set { x₂,x'₂,y₂,y'₂}, private data set { x_a,x'_a,y_a,y'_aAnd a private data set { x }_b,x'_b,y_b,y'_b}; wherein, { x₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bThe data X is obtained by random decentralized processing of input data, y₁,y'₁,y₂,y'₂,y_a,y'_a,y_b,y'_bThe data is obtained by carrying out random dispersion processing on input data Y;

according to the multi-party computing instruction generated by utilizing four computing nodes to execute the multiplication computing task of the input data X and Y, the computing engine executes the following steps:

enabling the first computing node and the second computing node to share a random number r₁₂And r'₁₂And having said third and fourth computing nodes share a random number r_abAnd r'_ab；

The first computing node and the second computing node respectively carry out multiplication computation on the private data groups held by the first computing node and the second computing node and are used for offsetting the random number r₁₂And r'₁₂So that the first computing node gets the intermediate data t₁And t'₁And the second computing node obtains the intermediate data t₂And t'₂；

The third computing node and the fourth computing node respectively carry out multiplication computation on the private data groups held by the third computing node and the fourth computing node and are used for offsetting the random number r_abAnd r'_abSo that the first computing node gets the intermediate data t_aAnd t'_aAnd the second computing node obtains the intermediate data t_bAnd t'_b；

Causing the first compute node and the third compute node to permute a respective one of the intermediate data, and the first compute node and the fourth compute node to permute a respective one of the intermediate data; causing the second compute node and the third compute node to permute a respective one of the intermediate data, and the second compute node and the fourth compute node to permute a respective one of the intermediate data;

and enabling each computing node to perform local computation including addition by using the intermediate data paired based on the permutation operation, so that each computing node obtains two computation results including the cancelable random numbers.

12. The method of computing input data according to claim 10, wherein the computing task comprises a computing task of two mathematical computations of input data, the computing engine generating no more than 2 x 4 permutations of data based communication during execution of the computing task.

13. The method of claim 10, wherein the private data and the shared random number are both a value range Z_2nProduces a data communication of no more than 2n × 4 bits of data during the performance of the computing task.

14. The input data calculation method according to claim 9, wherein the calculation task includes three calculation tasks for mathematical calculation of the input data; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises the following steps: enabling the four computing nodes to obtain first computing results of respective held corresponding input data X and Y computing by utilizing data interaction of the first replacement data and taking the first computing results as intermediate data; enabling the four computing nodes to obtain the computing results held by the computing nodes by utilizing data interaction of the intermediate data for replacing the data for the second time; and having four of the compute nodes perform local computations based on the random numbers before permuting the data twice.

15. The method according to claim 14, wherein the step of performing local computation on the private data groups acquired by the computing nodes according to the multi-party computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes comprises:

a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x1, y1 ', z1}, a private data set { x2, y 2', z2}, a private data set { xa, ya ', za }, and a private data set { xb, yb', zb }; wherein { X1, X2, xa, xb } is obtained by subjecting input data X to random dispersion processing, { Y1 ', Y2', ya ', yb' } is obtained by subjecting input data Y to random dispersion processing, and { Z1, Z2, za, zb } is obtained by subjecting input data Z to random dispersion processing;

in accordance with multi-party computing instructions generated by performing a multiply compute task of input data X, Y and Z using four compute nodes, the compute engine performs the steps of:

And

number ofLearning calculation so that the first calculation node obtains intermediate data t₁The second computing node obtains intermediate data t₂The third computing node obtains intermediate data t_aThe fourth computing node obtains intermediate data t_b；

The first computing node and the third computing node replace respective intermediate data; the second computing node and the third computing node replace respective intermediate data;

each computing node performs mathematical computation of multiplication by using each held intermediate data and private data corresponding to the input data Z, so that the first computing node obtains the intermediate data s₁The second computing node obtains intermediate data s₂The third computing node obtains intermediate data s_aThe fourth computing node obtains intermediate data s_b；

The first computing node and the second computing node respectively carry out the mutual held intermediate data s₁And s₂Performing multiplication and for cancelling the random number r₁₂And r'₁₂So that the first computing node obtains intermediate data h₁And h'₁And the second computing node obtains intermediate data h₂And h'₂；

The third computing node and the fourth computing node respectively carry out the mutual held intermediate data s_aAnd s_bPerforming multiplication and for cancelling the random number r_abAnd r'_abSo that the third computation node gets the intermediate data h_aAnd h'_aAnd the fourth computing node obtains intermediate data h_bAnd h'_b；

16. The method of computing input data according to claim 14, wherein the computing task comprises three computing tasks for mathematical computation of the input data, and the computing engine generates no more than 3 x 4 times data communication based on the permuted data during execution of the computing tasks.

17. The method of claim 14, wherein the private data and the shared random number are both value ranges

Produces a data communication of no more than 3n × 4 bits of data during the performance of the computing task.

18. The input data computing method of claim 9, wherein the computing task includes a computing task of extracting binary bits in the input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises: the four computing nodes obtain respective supporting computing results by utilizing data interaction of k rounds of 1-bit replacement data, wherein the computing results are used for extracting binary bits in the input data X; and k is the binary digit number to be extracted corresponding to the input data X in the calculation task.

19. The method of computing input data according to claim 18, wherein each computing node produces no more than k +1 data communications.

20. The method of computing input data according to claim 18, wherein each computing node generates data traffic with no more than a2 kbit data volume.

21. The method of computing input data according to claim 18, wherein each compute node produces no more than 1.5 kbit data traffic.

22. The input data computing method of claim 18, wherein the computing task includes a computing task of extracting binary bits in the input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises:

a first computing node, a second computing node, a third computing node and a fourth computing node in the computing engine sequentially acquire a private data set { x }₁}, private data set { x₂}, private data set { x_aAnd a private data set { x }_b}; wherein, { x₁,x₂,x_a,x_bThe secret data are binary expressed secret data obtained by carrying out random dispersion processing on the input data X, wherein each secret data and the input data X have the same binary digit number k;

according to the calculation instruction, the calculation engine executes the following steps:

each compute node initializes a bit value for output { c }₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}; and enabling the first computing node and the second computing node to share a random number r₁₂And b₁₂(ii) a And making the third computing node and the fourth computing node share a random number b_ab(ii) a Wherein the random number r₁₂、b₁₂And b_abIs a binary random number generated based on the number of extracted bits k;

the first computing node and the second computing node use the random number r₁₂For respectively held private data x₁And x₂Logic processing is carried out on the low-k bits to obtain binary intermediate data u with low-k bits unified₁And u₂；

Let the first computing node intermediate data u₁Sent to the third computing node and processed by the third computing node based on the formula u₁∧x_aAnd obtaining intermediate data u_a；

Based on the k value, the following loop calculation is set: each computing node is used for generating private data x₁With the random number b based on the sharing₁₂Or b_abAnd obtaining the intermediate data of the ith round; performing replacement processing on the intermediate data obtained in each turn, and assigning corresponding output bits; the first computing node and the third computing node perform replacement processing on the intermediate data, and the second computing node and the fourth computing node perform replacement processing on the intermediate data;

each computing node utilizes the assigned output bit and the random number to carry out logic computation on the k bit value of the private data held by each computing node to obtain a computation result;

the first computing node is to compute result c'₁To a third computing node; the second computing node will compute result c'₂To a fourth computing node; the third computing node will compute the result c_aTo a second computing node; the fourth computing node calculates the result c_bProvided to the first compute node so that each compute node holds two compute results.

23. The method according to claim 18, wherein the calculation task includes a calculation task of comparing two input data, and the four calculation nodes are caused to perform local calculation and data interaction according to a multiparty calculation instruction set based on a two-input-data subtraction calculation task and a bit extraction calculation task, and obtain bit values held by the calculation nodes.

24. The method according to claim 9, wherein the step of performing local computation on the private data groups acquired by the computing nodes according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes comprises: and executing multi-party calculation instructions set based on the careless transmission protocol by using four calculation nodes and obtaining calculation results held by the calculation nodes.

25. The method for computing input data according to claim 24, wherein the step of executing the multiparty computing instruction set based on the oblivious transfer protocol by using four computing nodes and obtaining the respective held computing results comprises: enabling the four computing nodes to perform local computation and data interaction based on sharable random bit values used for indicating transmission/non-transmission of corresponding private data, and obtaining respective computation results; wherein the calculation result comprises a result for indicating that the corresponding private data is transmitted or a result for indicating that the corresponding private data is not transmitted.

26. The input data calculation method according to claim 24, wherein the calculation task includes a calculation task of inadvertently transmitting the input data X; the step of performing local computation on the private data groups acquired by the computing nodes respectively according to the computation instruction, and performing interaction on intermediate data generated by the local computation to obtain computation results held by the computing nodes respectively comprises:

the private data obtained by each computing node in the computing engine are { x }₁,x'₁}，{x₂,x'₂}，{x_a,x'_a}，{x_b,x'_b}; wherein the private data { x₁,x'₁,x₂,x'₂,x_a,x'_a,x_b,x'_bObtaining input data X through random dispersion processing;

each computing node obtains sharable random bit value { c) set based on private data to be shared respectively₁,c'₁}，{c₂,c'₂}，{c_a,c'_a}，{c_b,c'_b}；

According to the multi-party computing instruction generated by executing the computing task of transmitting the input data X carelessly by using four computing nodes, the computing engine executes the following steps:

enabling the first computing node and the second computing node to share a first random number r₁₂And r'₁₂(ii) a The first computing node and the third computing node share a second random number r'_1a(ii) a The first computing node and the fourth computing node share a second type of random number r_1b(ii) a Enabling the second computing node and the third computing node to share a second type random number r_2a(ii) a The second computing node and the fourth computing node share a second random number r'_2b(ii) a Enabling the third computing node and the fourth computing node to share a first type of random number r_abAnd r'_ab；

Enabling each computing node to perform mathematical computation with a first type of random number on whether private data is transmitted or not by using the respectively configured bit value, and performing mathematical computation with a second type of random number on whether the first type of random number is transmitted or not by using the respectively configured bit value to obtain intermediate data and an intermediate random number;

the first computing node and the second computing node respectively perform replacement operation of intermediate data and intermediate random numbers with the third computing node and the fourth computing node;

and enabling each computing node to execute mathematical computation including the cancellation of the second random number, and obtaining the respective held computation result.

27. The method of computing input data according to claim 24, wherein the computing engine generates no more than 4 x 4 permutations of data based communications during the execution of the computing task.

28. The method of claim 24, wherein the private data and the shared random number are both value ranges

Produces a data communication of no more than a 4n × 4 bit data volume during the performance of the computing task.

29. The method of computing input data according to claim 1, wherein the step of the compute engine obtaining multi-party compute instructions corresponding to the compute task comprises: each computing node acquires the multi-party computing instruction and the computing role; and each computing node executes the multi-party computing instruction according to the respectively acquired computing role.

30. The method of computing input data according to claim 1, wherein the step of the compute engine obtaining multi-party compute instructions corresponding to the compute task comprises: and each computing node respectively acquires a corresponding locally executed computing instruction in the multi-party computing instruction.

31. The input data computing method according to claim 1, further comprising sending the computing results held by two of the four computing nodes to a data acquisition device, so that the data acquisition device generates a processing result corresponding to the computing task based on the obtained computing results.

32. A computing engine, comprising: the four computing nodes are used for cooperatively computing a multi-party computing instruction corresponding to a computing task; the computing task is used for carrying out data processing on input data;

the four computing nodes executing the multi-party computing method according to any one of claims 1-31 based on the obtained multi-party computing instruction and the obtained private data set; and each private data set is obtained by the input data based on a random decentralized processing mode corresponding to the computing task.

33. A readable medium in a computing node, having stored thereon at least one program that, when invoked, participates in performing a multi-party computing method as claimed in any one of claims 1-31.

34. A task management platform, comprising:

storage means for storing at least one program;

interface means for communicating with a compute engine as claimed in any one of claims 1 to 31;

processing means for invoking said at least one program and coordinating said storage means and interface means to perform the following method:

acquiring a computing task; the computing task is used for carrying out data processing on input data;

converting the computing task into multi-party computing instructions executable by the computing engine of any of claims 1-31 and sending to the computing engine.