Method and apparatus for calculating privacy graphs

Abstract

This specification provides a technical solution for joint privacy graph computation by two parties. In a scenario where two parties jointly perform privacy graph computation, each party holds local graph data. The nodes in the graph data are divided into two categories: second-class nodes (common nodes) and first-class nodes (non-common nodes). The overall graph computation architecture employs homomorphic encryption. For second-class nodes, parameter information is synchronized in each computation cycle. This parameter information synchronization process combines conversion between different privacy computation methods, ultimately existing as homomorphically encrypted ciphertext of the synchronized value, which is then used by both parties to perform homomorphic ciphertext computation locally. This effectively reduces the communication volume during joint computation and improves the efficiency of the two-party privacy graph computation.

Description

Technical Field

[0001] This specification relates to the field of secure computing technology, and more particularly to methods and apparatus for privacy graph computing. Background Technology

[0002] A graph is a data structure composed of vertices and edges, and can include bipartite graphs, knowledge graphs, etc. Graph data processing (graph analysis) can perform multi-round iterative computations on a graph, with each round of analysis yielding new representations based on the current vertex representations. Graph analysis has wide applications in various fields, such as webpage rating, fraud detection, and protein classification.

[0003] In practical applications, graph data is often distributed across multiple institutions (data providers). In some cases, due to privacy concerns among different data providers or restrictions on data sharing, graph data may not be shared between institutions. For example, in financial scenarios, transfer graphs (accounts as vertices and transfer records as edges) are highly sensitive data distributed across different financial institutions and cannot be directly shared with other financial institutions. For graph analysis tasks, a wider volume of data leads to higher-quality analysis results. For instance, in detecting financial fraud on transfer graphs, analyzing the union of the data from both institutions may uncover more potential financial fraud samples and improve the accuracy of the analysis results compared to each institution analyzing its own known transfer graph. However, because sensitive graph data cannot be directly shared, neither party can directly perform analysis on the union.

[0004] With the development of privacy-preserving computation technology, techniques such as obfuscated circuits, secret sharing, and homomorphic encryption have made it possible for multiple parties to analyze the union of their data. In principle, this ensures that each party can only know the pre-agreed analysis results and cannot access other private data. Privacy-preserving computation allows different parties to provide their own private data as input to obtain computation results, but the parties do not disclose their private input data to each other. For example, homomorphic encryption privacy-preserving computation technology allows one party to perform operations such as addition and multiplication on the encrypted data without knowing the plaintext data itself. In secret-sharing privacy-preserving computation, a single piece of data is split among different parties through addition or other methods, making it impossible for any single party to directly know the true value of the data.

[0005] Multi-party privacy graph computation allows multiple data parties to collaboratively perform graph analysis with privacy protection in mind. Conventional multi-party privacy graph computation, using standard graph computation algorithms, employs a single encryption technique for privacy computation, such as secret sharing. Therefore, its communication complexity is typically high, impacting graph computation efficiency and even becoming a bottleneck when dealing with large-scale graph data. Reducing the communication volume in privacy graph computation has become an important and challenging problem in graph analysis. Summary of the Invention

[0006] This specification describes one or more embodiments of a method and apparatus for privacy graph computation, which addresses one or more problems mentioned in the background art.

[0007] According to a first aspect, a method for privacy graph computation is provided, for joint secure graph computation by a first party and a second party, wherein the first party holds a first graph, and the nodes in the first graph include second-type nodes shared with a second graph held by the second party, and first-type nodes other than the second-type nodes. In a single computation cycle of the graph computation, the method includes: obtaining parameter ciphertexts corresponding to the parameters of each node, wherein the parameter ciphertexts are encrypted in the form of a second key provided by the second party, the parameter ciphertexts of a single first-type node are determined locally, and the parameter ciphertexts of a single second-type node are determined by secure negotiation with the second party in a secret-sharing manner and securely converted into synchronization value ciphertexts in a local homomorphic encryption form; using the parameter ciphertexts of each node, performing homomorphic ciphertext computation operations on the nodes in the first graph based on the corresponding parameters to obtain the respective ciphertexts corresponding to each node.

[0008] In one embodiment, during the initial computation cycle, the ciphertext of the parameters of a single first-type node is determined by encrypting the parameters of the single first-type node using a second key; during non-initial computation cycles, the ciphertext of the parameters of a single first-type node is determined by the ciphertext calculated in the previous computation cycle.

[0009] In one embodiment, during the initial computation cycle, the first parameter value of the single second-type node on the first party and the second parameter value on the second party are both in plaintext form. The encrypted parameter of the single second-type node is determined by negotiation with the second party according to a predetermined synchronization strategy in the following manner: when the predetermined synchronization strategy is to take the maximum value or the minimum value, a secure comparison is performed with the second party under the form of secret sharing to determine the larger or smaller value of the first parameter value and the second parameter value as the synchronization value, and the first fragment of the synchronization value is obtained during the secure comparison process; when the predetermined strategy is to sum or take the average, the following secure calculation is performed with the second party: the first parameter value is split into the sum of two sub-values, and one sub-value of each of the first parameter value and the second parameter value is exchanged with the second party; the sub-value of the first parameter value retained locally and the sub-value of the second parameter value obtained from the second party are processed according to the predetermined strategy to obtain the first fragment of the synchronization value.

[0010] In one embodiment, during a non-initial computation cycle, the first party holds the encrypted first parameter value of the aforementioned single second-type node, and the second party holds the encrypted second parameter value of the aforementioned single second-type node; the encrypted parameter value of the single second-type node is determined by negotiating with the second party according to a predetermined synchronization strategy in the following manner: jointly with the second party, the first encrypted parameter value and the second encrypted parameter value are each converted into plaintext data in a secret sharing form; using the plaintext data in the secret sharing form, the first fragment of the synchronization value is obtained by performing secure computation with the second party based on the predetermined synchronization strategy.

[0011] In one embodiment, for a first node in the first graph, the calculation includes: fusing the parameter ciphertexts of the first node and each of its neighboring nodes by one of the following methods: summation, averaging, taking the maximum value, taking the minimum value, taking the median, or weighted summation.

[0012] According to a second aspect, an apparatus for privacy graph computation is provided, for a first party and a second party to jointly perform security graph computation, wherein the first party holds a first graph, and the nodes in the first graph include second type nodes shared with the second graph held by the second party, as well as first type nodes other than the second type nodes; the apparatus includes: an acquisition unit and a computation unit;

[0013] In a single computation cycle of graph calculation:

[0014] The acquisition unit is configured to acquire the parameter ciphertext corresponding to the parameters of each node respectively, wherein the parameter ciphertext is in the form of encryption by the second key provided by the second party, the parameter ciphertext of a single first-type node is determined locally, and the parameter ciphertext of a single second-type node is determined by secure negotiation with the second party in the form of secret sharing, and is securely converted into the synchronization value ciphertext in the form of local homomorphic encryption.

[0015] The computing unit is configured to use the parameter ciphertext of each node to perform homomorphic ciphertext calculations on the nodes in the first graph based on the corresponding parameters, so as to obtain the respective ciphertexts corresponding to each node.

[0016] In one embodiment, during the initial computation cycle, the first parameter value of the aforementioned single second-type node on the first party and the second parameter value on the second party are both in plaintext form. The acquisition unit is configured to negotiate with the second party to determine the encrypted parameter of the single second-type node according to a predetermined synchronization strategy in the following manner: when the predetermined synchronization strategy is to take the maximum value or the minimum value, a secure comparison is performed with the second party under a secret sharing form to determine the larger or smaller value of the first parameter value and the second parameter value as the synchronization value, and the first fragment of the synchronization value is obtained during the secure comparison process; when the predetermined strategy is to sum or take the average, the following secure calculation is performed with the second party: the first parameter value is split into the sum of two sub-values, and one sub-value of each of the first parameter value and the second parameter value is exchanged with the second party; the sub-value of the first parameter value retained locally and the sub-value of the second parameter value obtained from the second party are processed according to the predetermined strategy to obtain the first fragment of the synchronization value.

[0017] In another embodiment, during a non-initial aggregation cycle, the first party holds the encrypted first parameter value of the aforementioned single second-type node, and the second party holds the encrypted second parameter value of the aforementioned single second-type node; the acquisition unit is configured to negotiate with the second party to determine the encrypted parameter value of the single second-type node according to a predetermined synchronization strategy in the following manner: jointly with the second party, converting the encrypted first parameter value and the encrypted second parameter value into plaintext data in a secret sharing form; using the plaintext data in the secret sharing form, performing secure calculations with the second party based on the predetermined synchronization strategy to obtain the first fragment of the synchronization value.

[0018] According to a third aspect, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed in a computer, causes the computer to perform the method of the first aspect.

[0019] According to a fourth aspect, a computing device is provided, including a memory and a processor, characterized in that the memory stores executable code, and when the processor executes the executable code, it implements the method of the first aspect.

[0020] In a privacy graph computation scenario jointly performed by two parties using the methods and apparatus provided in the embodiments of this specification, each party holds local graph data. Considering that there are only a few common nodes during the computation process, the nodes in the graph data are classified into two categories: second-class nodes (common nodes) and first-class nodes (non-common nodes). To save communication bandwidth, the overall architecture adopts a computation method where each party performs computation using the other party's encryption key in a homomorphic encryption form. For the second-class nodes, since the two parties may have different parameters used for computation, parameter information synchronization between the two parties is performed in each computation cycle. This parameter information synchronization process is combined with the conversion of the privacy computation form, and the final result is stored in the ciphertext form of the synchronization value, which is then used by each party to perform homomorphic ciphertext computation locally. In this way, the communication bandwidth can be reduced to the communication during the parameter information synchronization process of the second-class nodes, effectively saving communication bandwidth and greatly improving the efficiency of privacy graph computation between the two parties. Attached Figure Description

[0021] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 This diagram illustrates an implementation architecture of the technical concept described in this specification.

[0023] Figure 2 This illustrates the interaction diagram between two parties during a computation cycle in a privacy graph computation process according to one embodiment.

[0024] Figure 3 This diagram illustrates an interaction diagram of parameter value synchronization between two parties in a privacy graph computation process, representing a specific example.

[0025] Figure 4 A flowchart illustrating privacy graph computation performed by a first party according to one embodiment is shown;

[0026] Figure 5 A flowchart illustrating the parameter value synchronization process performed by a first party during privacy graph computation according to one embodiment is shown.

[0027] Figure 6 A schematic block diagram of a privacy graph computing device according to one embodiment is shown. Detailed Implementation

[0028] The technical solutions provided in this specification are described below with reference to the accompanying drawings.

[0029] Figure 1This illustrates a specific architecture for graph data involving two parties. For example... Figure 1 As shown, the first and second parties, as data holders, each hold graph data generated based on business data from their respective business partners. These business partners can be service providers offering pre-booked services, such as financial service providers (banks, financial service platforms, etc.) or telecommunications service providers (telecom operators). Depending on the specific business partner, the corresponding business data differs, as do the nodes (also vertices) and connections in the graph data. For example, in financial services, this might correspond to transfer data, resulting in a transfer relationship graph. Nodes in this graph could be identifiable user identifiers such as financial accounts or identity verification codes (e.g., a bank card number corresponds to a user identifier), and connections could be transfer relationships, where a transfer record exists between two nodes connected by an edge. Similarly, in telecommunications services, this might correspond to telephone call data, resulting in a call relationship graph. Nodes in this graph could be a communication account with independent calling capabilities (e.g., a mobile phone number), and connections could be call relationships, where a call record exists between two nodes connected by an edge. Thus, the graph data built by a single data provider based on the corresponding business data could be a bipartite graph, a knowledge graph, etc. The graph data of a single business unit may not be completely connected.

[0030] In some business scenarios, the business data processed by a single business entity can be extended to other business entities. For example, interbank transfers in financial services involve the financial accounts of two different financial entities, and telephone transactions can involve communication accounts across different telecom operators, thus generating interaction. Therefore, the graph data constructed by two data holders, each holding data from one of the two business entities, may have overlap. For example... Figure 1 As shown, blank circles represent the business entities of the first party (such as financial accounts or communication accounts), and gray circles represent the business entities of the second party. Because the cross-party business data is recorded separately by the two parties, the second party's account entities (such as B, D, etc.) may appear in the first party's graph data, and the first party's account entities (such as A, C, E, etc.) may appear in the second party's graph data. Thus, there may be common edges in the graph data of the first and second parties, such as... Figure 1 Examples of bolded connecting edges include A→B, C→D, D→E, etc. In such cases, graph data analysis may achieve better results through a combination of first-party and second-party analysis.

[0031] A common edge connects two nodes, typically one on the first side and the other on the second side. Therefore, the common edge usually contains data publicly available to both the first and second parties. Data from nodes on the first side (e.g., A and B) is typically inaccessible to the second party, and vice versa. Thus, the first and second parties may hold different data for a single common node.

[0032] In the process of graph-based data analysis and computation between the first and second parties, it is often necessary to calculate neighbor node information, such as in graph neural networks and PageRank methods. This can be done using a secure computation architecture while protecting the data privacy of both parties. For example, a single layer of a graph neural network can calculate the weighted representations of the current node's neighbors to update the current node's representation; a single iteration of PageRank can calculate the weights (e.g., the degree) of each neighbor node of the current node and use them to update the current node's computation message, with each node's weight updated in a single iteration based on the neighbor node weights from the previous iteration. To fully utilize the data from the first and second parties regarding common nodes, joint privacy graph computation can be performed by the first and second parties.

[0033] Assuming |V| represents the number of vertices in the graph and |E| represents the number of edges, common graph analysis methods and their complexities include:

[0034] 1. Using an adjacency matrix to represent graph data, when used for graph analysis, the adjacency matrix needs to be scanned once in each iteration, resulting in a communication complexity of O(|V|). 2 );

[0035] 2. Based on a two-way obfuscated circuit representation, a unified obfuscated circuit list for points and edges is used to represent graph data. In each iteration of graph analysis, a bitonetic sorting method is used twice, reducing the communication complexity to below quadratic, O((|V|+|E|)log). 2 (|V|+|E|));

[0036] 3. Based on the three-party secret sharing representation, it also uses a unified list of points and edges to represent graph data. However, it only needs to perform sorting with a communication volume of O((|V|+|E|)log(|V|+|E|)) in the first iteration. In subsequent iterations, it only needs to perform permutation instead of sorting, thus achieving a communication complexity of O(|V|+|E|).

[0037] etc.

[0038] Of the methods listed above, experiments show that the bottleneck in reducing their runtime lies in the communication part. When the communication complexity is related to the number of edges |E|, the overall communication time is relatively high. Furthermore, the solution with the lowest communication complexity, O(|V|+|E|), is often suitable for three-party scenarios, while privacy graph computation for two parties is more challenging.

[0039] To address the communication bottleneck in privacy graph computation between two parties, this specification proposes a technical concept that categorizes the nodes in a single data party's graph into two types, denoted as Type I nodes and Type II nodes, respectively. The technical scenario described in this specification assumes that both the first and second parties possess graph data constructed from local business data, denoted as Graph I and Graph II, respectively. In the interaction between the first and second parties, local nodes of the first and second parties are connected, with the corresponding connecting edges serving as common edges. Type I nodes can be nodes whose neighboring nodes are all local nodes, while Type II nodes are nodes whose neighboring nodes include non-local nodes. Alternatively, Type II nodes can be understood as common nodes or nodes connected by common edges, i.e., the nodes involved in the interaction between the first and second parties (such as interbank transfers, inter-carrier calls, etc.).

[0040] Under the technical concept described in this specification, both the first and second parties can perform graph computations using homomorphically encrypted parameter ciphertext. Here, parameters can be various parameters used for computation, such as node representation vectors in graph neural networks or weights in PageRank-based graph analysis. Specifically, the local party holds the ciphertext encrypted with the other party's encryption key (i.e., homomorphic ciphertext), while the other party holds the corresponding decryption key, thus preventing either party from directly decrypting the computation result. Depending on whether the graph algorithm involves homomorphic multiplication, a semi-homomorphic or fully homomorphic encryption method can be chosen. For the first type of node, its initial or intermediate parameter values ​​are local. For the second type of node, the parameter values ​​held by the other party also need to be considered. Therefore, in each graph computation cycle, the parameters of the second type of nodes held by both parties can be synchronized in a secret-sharing manner to determine a shared synchronization value. This shared synchronization value is then converted into homomorphic ciphertext forms for both parties, allowing computation to be completed locally using homomorphic encryption. Each party then obtains the corresponding ciphertext of the computation result based on its local graph computation. Since computation under homomorphic encryption does not require communication, the amount of communication is reduced to secret sharing communication during the synchronization process of the second type of nodes, and communication during the conversion process between homomorphic encryption and secret sharing, which greatly reduces the amount of communication.

[0041] The following is in conjunction with the appendix Figure 2 The technical concept of this specification is described in detail with specific examples.

[0042] like Figure 2As shown, assuming the first party is denoted as P0, the second party as P1, V as nodes, and E as connecting edges, the graph data held by the first party is denoted as {V0, E0}, and the graph data held by the second party is denoted as {V1, E1}. The common edge generated by the first and second parties based on cross-business (both parties can obtain the relevant information) is denoted as {E... p The nodes connected by the common edge are the second type of nodes, such as {V}. p Additionally, each party holds a key pair and keeps the decryption key (e.g., private key) locally, sending the encryption key (e.g., public key) to the other party. Figure 2 In this process, the first party provides the second party with a first key Pk0, so that the second party's calculations are performed based on the homomorphic ciphertext encrypted with the first key Pk0. The second party provides the first party with a second key Pk1, so that the first party's calculations are performed based on the homomorphic ciphertext encrypted with the second key Pk1. Both the first and second parties retain decryption keys corresponding to the first key Pk0 and the second key Pk1, respectively, which are used to decrypt the values ​​encrypted with the corresponding keys to obtain the plaintext data.

[0043] Initially, both the first and second parties can determine parameters based on their local business data. These parameters can be determined according to the business objectives or logic of graph computation or graph analysis, such as node representation vectors (e.g., graph analysis frameworks based on graph neural networks) or weights (e.g., scalar values ​​in a PageRank-based graph analysis framework, such as the degree of a node). These parameters serve as input data for graph computation. For example, in graph data-based business processing, for each node, the parameters of its neighboring nodes can be aggregated to the current node. The computation result can be called an aggregated message. The calculated parameters can be updated through one of the following: the corresponding aggregated message itself, or other information determined by the aggregated message (e.g., node weights obtained by further processing the aggregated message in a PageRank-based graph analysis framework), without limitation here.

[0044] It is understandable that second-type nodes coexist in both the first and second parties, but may have different graph computation parameter values. For example, if the first node is any second-type node, its parameter value in the first party is denoted as the first parameter value, and its parameter value in the second party is denoted as the second parameter value. Therefore, the first and second parties can negotiate a shared parameter value for each second-type node according to a predetermined synchronization strategy, such as denoted as the synchronization value.

[0045] refer to Figure 2 As shown, with the first node V pFor example, the first party and the second party can negotiate the corresponding synchronization value of the first node based on the first parameter value and the second parameter value, according to a predetermined synchronization strategy. This synchronization value is secretly shared between the first party and the second party, and the first party holds the first fragment (V) of the synchronization value. p 0, the second party holds the second fragment (V) of the synchronization value. p 1. Among them, the pre-defined synchronization strategy can be to take the maximum value, take the minimum value, take the median, sum, take the average, etc.

[0046] Initially, the parameter values ​​of both parties are plaintext data locally. Therefore, they can directly negotiate the shared parameter synchronization values ​​using a secret sharing method. For example, if the predetermined method is to take the maximum or minimum value, a secure comparison method can be used to determine the two fragments of the corresponding synchronization value under the secret sharing form. If the predetermined method is summation or averaging, the first and second parties can each split the first and second parameter values ​​into two sub-values ​​(which can be considered fragments under the secret sharing form), sum them, and send one of the sub-values ​​to the other party. The other party then processes the received sub-value and the sub-value stored locally according to the predetermined synchronization strategy to obtain the secret sharing form of the synchronization value. Taking summation as an example, the first party sends the first node V... p The first parameter value w in the local area p0 Split into two sub-values ​​(w) p0 )0 and (w p0 )1, and (w p0 )1 is sent to the second party, and the second party will send the first node V p The second parameter value w in the local area p1 Split into (w p1 )0 and (w p1 )1, and (w p1 )0 is sent to the first party. The first party can send (w) p0 )0 and (w p1 Sum the results of the summations to determine the first node V. p The first fragment of the synchronization value, the second pair (w) p0 )1 and (w p1 )1. Sum the results to determine the first node V. p The second slice of the synchronization value. Figure 2 In this context, the parameters of the second type of node can be denoted as (V) in the first partition set of the first party. p )0, the second fragment set of the second party is denoted as (V) p 1.

[0047] To perform computations under homomorphic ciphertext, the parameters of the second type of node can be transformed from secret-shared form to homomorphic ciphertext form (denoted as A2H). Let's still consider the first node V... pFor example, on the one hand, the first party and the second party can each, based on their local encryption keys, split the first fragment (V) of the first node's first parameter value or second parameter value. p 0. Second segment (V) p Encrypt 1, and then encrypt the ciphertext (such as...) Figure 2 Pk0(V) p )0 or Pk1(V p 1) It is passed to the other party. On the other hand, the first party and the second party can also use the other party's encryption key to encrypt their local fragments to obtain the ciphertext encrypted with the other party's key (such as...). Figure 2 Pk1(V) p )1、Pk0(V p Thus, the first party obtains the encryption key from the second party and encrypts the first fragment of ciphertext Pk1(V). p )0 and the second fragment ciphertext Pk1(V p )1, The second party obtains the encryption key from the first party and encrypts the first fragment of ciphertext Pk0(V) p )0 and the second piece Pk0(V p )1, Thus, the first party and the second party each perform addition operations locally using homomorphic ciphertext to obtain the ciphertext form of the synchronization value of the second type of node, such as the first party obtaining Pk1(V p )=Pk1(V p )0+Pk1(V p )1, the second side yields Pk0(V p )=Pk0(V p )0+Pk0(V p 1. This achieves the conversion from the secret-shared form of the synchronization value obtained through negotiation to the homomorphic ciphertext form.

[0048] Thus, both the first and second parties can obtain the ciphertext of each type-two node encrypted with the other party's encryption key. According to the secure computation rules of homomorphic encryption, the first and second parties can also use the other party's encryption key to access their local type-two nodes (such as...). Figure 2 (V0-V) p (V1-V) p Encryption is performed to obtain the corresponding ciphertext, such as Pk1(V0-V p ), Pk0(V1-V pAt this point, the first party obtains the homomorphic ciphertext of the parameters of all local nodes {V0} encrypted with the second party's encryption key (second key), and the second party obtains the homomorphic ciphertext of the parameters of all local nodes {V1} encrypted with the first party's encryption key (first key). Thus, each party can use the homomorphic ciphertext of the parameter values ​​of its local graph data to calculate the information of neighboring nodes and obtain the calculation result. The calculation method varies depending on the business objective. Specifically, the calculation method may include summing, averaging, taking the maximum value, taking the minimum value, taking the median, weighted summing, etc., of the parameter values ​​of neighboring nodes (including or excluding themselves). Figure 2 In this context, the ciphertext in the first party's calculation result can be denoted as Pk1(V0), and the ciphertext in the second party's calculation result can be denoted as Pk0(V1).

[0049] Thus, the initial calculation cycle (e.g.) Figure 2 The steps within the dashed box in the diagram are completed. In subsequent calculation cycles, the above process is repeated, where the parameter values ​​for a single calculation cycle are determined based on the calculation results of the previous round. The parameter values ​​for subsequent calculation cycles can be the calculation results themselves; for example, if the parameter value is the current representation of a node in the graph, then the node representation calculated by the single-layer graph neural network can be used as information for the corresponding node in the next round of calculation. Alternatively, the parameter values ​​for subsequent calculation cycles can be determined by pre-processing the calculation results. For example, in the PageRank algorithm, the parameter is the node's weight, and the calculation result is determined by summing the weights of neighboring nodes. For example, the calculation result for the current node v is... w t-1 Here, is the weight corresponding to round t-1 (t = 1, 2, 3...), u is a first-order neighbor of v, w is the edge weight, and f is the weight of the edge. g f s Two algorithms are defined, such as f s For the product, f g To sum the values, the weight of the current node v can be updated to... w t It is the weight after the current round update, f A Another algorithm, such as addition, is defined.

[0050] The difference between the subsequent calculation cycle and the initial calculation cycle lies in the different synchronization methods for the current values ​​of the parameters of the second type of nodes. As mentioned earlier, both the first and second parties can determine the ciphertext values ​​of the parameters of their local second type of nodes based on the current calculation results, then negotiate and synchronize the synchronization values ​​of the parameters of the second type of nodes, and each party obtains the ciphertext form of the synchronization value encrypted with the other party's encryption key.

[0051] In other words, the current value of the parameter of the second type of node can be negotiated in ciphertext form. Taking the first node as an example again, if after the previous calculation cycle, the first party holds the ciphertext of the first parameter value Pk1(V)... p )0, the second party holds the second parameter value ciphertext Pk0(V p 1. The negotiation result is to first obtain a non-ciphertext secret sharing format, such as denoted as the first fragment (V). p )0 and the second piece (V p 1. Then convert it into encrypted form. The following is combined with... Figure 3 The negotiation process is described in detail below.

[0052] refer to Figure 3 As shown. The first party holds the ciphertext Pk1(V) of the first parameter value calculated for the first node in the previous calculation cycle. p The first party can generate a first reference random number, denoted as y0 (or -y0, the principle is the same, this article uses y0 as an example for description), and encrypt this first reference random number with the second key Pk1, denoted as Pk1(y0). Thus, the first party can calculate the ciphertext of the sum of the first parameter value and the first reference random number in homomorphic encryption, denoted as the first sum ciphertext: Pk1[(V p )0+y0]=Pk1(V p )0+Pk1(y0). Then, the first party P0 can cipher the first sum value Pk1[(V p The decryption key (which exists as a key pair with the encryption key Pk1) is sent to the second party P1. The second party P1 then uses its local decryption key (which exists as a key pair with the encryption key Pk1) to decrypt Pk1[(V p )0+y0], we can obtain the first sum (V) p )0+y0. Thus, the opposite of the first reference random number held by the first party P0, -y0, and the first sum (V) held by the second party p )0+y0 constitutes the secret sharing form of the first parameter value calculated by the first node in the previous round, that is, the conversion from homomorphic ciphertext to decrypted secret sharing form is completed (as denoted as H2A).

[0053] Similarly, for the second parameter value Pk0(V) calculated by the first node held by the second party in the previous calculation cycle, p Alternatively, the second reference random number y1 generated by the second party can be used to convert it into a decrypted secret sharing form, such as the fragment obtained by the first party being the second sum (V). pThe second party obtains a fragment of the second reference random number, -y1, where -y1 is the opposite of y1. In the secret-sharing format, the synchronization value of the first node (i.e., the parameters shared by both parties) can be determined according to predetermined synchronization strategies described above, such as taking the maximum value, taking the minimum value, summing, averaging, etc. The first party obtains the first fragment of the synchronization value, and the second party obtains the second fragment. Taking summing as an example, the first party can combine the two fragments it holds locally, -y0 and (V... p The sum of 1 + y1 is used as the first fragment of the synchronization value. The second party can then use the two fragments held locally -y1 and (V) p The sum of 0 and y0 is used as the second part of the synchronization value.

[0054] Similar to the initial computation cycle, in order to perform computation in homomorphic encryption, the first party can encrypt a first fragment of the synchronization value using its encryption key Pk0 and provide it to the second party. The second party then homomorphically sums the second fragment encrypted with the first party's encryption key Pk0 with the encrypted first fragment, obtaining the ciphertext of the synchronization value encrypted with the first party's encryption key Pk0. Similarly, the first party can obtain the ciphertext of the synchronization value encrypted with the second party's encryption key Pk1.

[0055] In this way, the first party can obtain the homomorphic ciphertext of all nodes (including first-type nodes and second-type nodes) encrypted using the second party's encryption key Pk1, and the second party can obtain the homomorphic ciphertext of all nodes encrypted using the first party's encryption key Pk0. Thus, the first party and the second party can each perform the calculation of the current calculation cycle in the ciphertext state of the corresponding encryption key.

[0056] Thus, after multiple computation cycles, the first and second parties each obtain the computation results or the parameters mentioned above from their local nodes. For the second type of node, the first and second parties may or may not negotiate and synchronize the computation results or parameters. The final computation results or parameters can be used for subsequent business processing, such as using weights or node representations to analyze the relationships between nodes.

[0057] Based on the above Figure 2 , Figure 3The principle described in this manual, and the privacy graph computation process, are applied in a scenario involving two data parties (referred to as Party 1 and Party 2, or simply the two parties). Because of the interaction between the business data of Party 1 and Party 2, they can jointly perform graph-based business processing. Here, the business entities in the interaction data are the entities corresponding to the nodes in the graph data, such as communication numbers or financial accounts. The interaction data includes transactions between the two entities, such as transfers and communications. Thus, the graph data of both parties has a common edge. The nodes connected by this common edge can be called common nodes, referred to as Class 2 nodes. Other value nodes can be referred to as Class 1 nodes.

[0058] In specific business processing, the first and second parties can each calculate the parameter values ​​of neighboring nodes for their local nodes to obtain the calculation results. Since the graph data of the first and second parties have intersections, namely common edges and second-type nodes, joint graph calculation by the two parties can effectively utilize each other's data and improve the accuracy of business processing.

[0059] It is understandable that the second type of nodes have different computational parameter values ​​in the graph data of both the first and second parties. To utilize each other's data, data synchronization can be performed on the common nodes (i.e., second type nodes) of both parties during each computation cycle of the graph computation. Assuming the first node is any node in the second type, in a single computation cycle, the first and second parties can respectively hold the first parameter value and the second parameter value corresponding to that first node.

[0060] The first and second parameter values ​​here are plaintext data on the local machine of the corresponding party during the initial calculation cycle. Under the technical concept of this specification, the calculation process is based on homomorphic computation of ciphertext encrypted with the other party's encryption key. Therefore, in subsequent calculation cycles (excluding the initial calculation cycle), the first and second parameter values ​​can be in ciphertext form, such as denoted as ciphertext of the first parameter value and ciphertext of the second parameter value. Here, the ciphertext is the ciphertext of the corresponding calculation parameter value of the first node based on the other party's encryption key. The calculation parameters can be the calculation result of the previous calculation round or determined based on further processing of the calculation result; no limitation is made here.

[0061] During the calculation, for the first node, synchronization is performed using the first and second parameter values ​​to determine the corresponding synchronization value. This synchronization can be achieved through secret sharing, and after determining the synchronization value, each party converts it into ciphertext using the other party's encryption key.

[0062] Figure 4The flowchart illustrating privacy graph computation according to an embodiment of this specification is shown. This process is performed by a single participant in the privacy graph computation, such as a first party. The corresponding executing entity is a computer, device, server, etc., with certain computing capabilities corresponding to the first party. Figure 4 As shown, the process of privacy graph computation performed by the first party may include the following steps: Step 401, obtaining the parameter ciphertext corresponding to the parameters of each node, wherein the parameter ciphertext is in the form of encryption by the second key provided by the second party, the parameter ciphertext of a single first-type node is determined locally, and the parameter ciphertext of a single second-type node is determined by secure negotiation with the second party in the form of secret sharing and is securely converted into the synchronization value ciphertext in the form of local homomorphic encryption; Step 402, using the parameter ciphertext of each node, performing homomorphic ciphertext computation on the nodes in the first graph based on the corresponding parameters to obtain the respective ciphertexts corresponding to each node.

[0063] First, in step 401, the parameter ciphertext corresponding to the parameters of each node is obtained.

[0064] The parameters here can be various parameters of the nodes used for graph computation, such as the node representation vector in graph neural network computation, the node weights in PageRank graph analysis, etc.

[0065] According to the data processing rules of homomorphic encryption, the parameter ciphertext here is encrypted using the second key provided by the second party. Typically, the parameter ciphertext of a single Type I node can be determined locally by the first party. In the initial computation cycle, the parameter ciphertext of a single Type I node is determined by encrypting its computation parameter plaintext using the second key (the encryption key provided by the second party). In non-initial computation cycles, the parameter ciphertext of a single Type I node is determined by its computation message from the previous computation cycle. For example, if the parameter ciphertext was calculated using homomorphic ciphertext in the previous computation cycle, it is directly used as the parameter for the current computation cycle.

[0066] The ciphertext of the parameters for a single Type II node is a synchronized value ciphertext determined through secure negotiation with the second party. This secure negotiation process involves a conversion between secret-sharing and homomorphic encryption methods. Figure 5 As shown, it includes the following steps.

[0067] Step 501: Based on the first parameter value of the single second-type node locally and the predetermined synchronization strategy, a first fragment of the synchronization value is obtained by performing secure calculation with the second party in a secret sharing manner.

[0068] It is understandable that the predetermined strategy can be one of the following: summation, averaging, taking the maximum value, taking the minimum value, taking the median, summation, averaging, weighted average, etc.

[0069] In the initial computation cycle, the first and second parameter values ​​are plaintext data from the first and second parties, respectively, and are relatively easy to convert into a secret-shared form. With the predetermined synchronization strategy of taking the maximum and minimum values, secure computation using a secure comparison method with the second party can yield the secret-shared form of the synchronization value, and the first fragment of the synchronization value can be obtained locally. With the predetermined strategy of summation and averaging, the first party can perform the following secure computation with the second party: split the first parameter value into the sum of two sub-values ​​(modulo in the secret-shared form), exchange one sub-value of each of the first and second parameter values ​​with the second party; process the locally retained sub-value of the first parameter value and the sub-value of the second parameter value obtained from the second party according to the predetermined synchronization strategy, such as summation or averaging, to obtain the first fragment of the synchronization value.

[0070] During non-initial computation cycles, both the first parameter value ciphertext and the second parameter value ciphertext are in local homomorphic ciphertext form. They can be converted into plaintext secret sharing form first, and then processed based on a predetermined synchronization strategy to determine the secret sharing form of the synchronization value for the first and second parties.

[0071] For example, the first party can generate a first reference random number and determine its opposite as the first slice of the first parameter value. On the other hand, the first reference random number is encrypted with a second key and then homomorphically summed with the ciphertext of the first parameter value to obtain a first sum ciphertext. This first sum ciphertext is provided to the second party, who can then decrypt it using the decryption key corresponding to the second key to obtain the first sum as the second slice of the first parameter value. This first sum and the opposite of the first reference random number constitute a secret-shared form of the first parameter value.

[0072] Similarly, the second party can perform a similar operation to generate a second reference random number and determine its opposite as the second fragment of the second parameter value. On the other hand, after encrypting the second reference random number with the first key, it performs a homomorphic summation with the second parameter value ciphertext to obtain a second sum ciphertext, which is then provided to the first party. The first party uses the decryption key corresponding to the first key to decrypt the second sum ciphertext, obtaining the second sum as the first fragment of the second parameter value. This second sum and the opposite of the second reference random number constitute the secret-shared form of the second parameter value.

[0073] Similar to the initial calculation cycle, the first party can perform secure calculations with the second party based on the aforementioned second sum (plaintext fragment of the second parameter value) and the opposite of the first reference random number (plaintext fragment of the first parameter value) to obtain the first fragment of the synchronization value based on a predetermined synchronization strategy.

[0074] In this way, the corresponding fragments of the synchronization value can be determined by both parties in the form of secret sharing.

[0075] In optional examples, other homomorphic encryption methods can be used to determine the secret sharing form of the first parameter value and the second parameter value, and the first party obtains the first fragment of the synchronized value, and the second party obtains the second fragment of the synchronized value. This will not be elaborated further here.

[0076] Based on each fragment, the secret sharing format can be converted into homomorphic ciphertext formats for the first and second parties respectively.

[0077] Step 502: Based on the synchronization value, the first fragment and the second party jointly perform a secure conversion from secret sharing to homomorphic encryption to obtain the synchronization value ciphertext.

[0078] The conversion from secret sharing to homomorphic encryption can be performed using conventional methods. A specific example is provided below to illustrate this.

[0079] The first party obtains a first ciphertext by encrypting a first fragment of the synchronization value using the second key. Conversely, it can receive a second ciphertext from the second party by encrypting a second fragment of the synchronization value using the first key. The first party performs a homomorphic summation between the first ciphertext and the second ciphertext obtained from the second party to obtain the first node's synchronization value ciphertext in the second key encryption format. The second party can obtain a third ciphertext by encrypting a second fragment of the synchronization value using the first key. Conversely, it can receive a fourth ciphertext from the first party by encrypting a second fragment of the synchronization value using the second key. The second party performs a homomorphic summation between the third ciphertext and the fourth ciphertext obtained from the first party to obtain the first node's synchronization value ciphertext in the first key encryption format.

[0080] Then, via step 402, using the parameter ciphertext of each node, the nodes in the first graph are calculated in homomorphic ciphertext form based on the corresponding calculation parameters to obtain the respective ciphertexts corresponding to each node.

[0081] Under the technical concept of this specification, the computation processes of the first party and the second party in graph computation can be independent of each other. For example, the synchronization value ciphertext obtained by the first party is a synchronization value ciphertext encrypted with the second key, which, together with the first type of nodes, forms a homomorphic encryption form, both encrypted with the second key. This allows all nodes in the local graph data to perform local graph computation together under homomorphic encryption, obtaining the ciphertext of the computation results for each node in the local graph data. Similarly, the second party can use parameters encrypted with the first key to perform computation operations locally.

[0082] Taking the above calculation as an example of neighbor node information aggregation, for a single node, the calculation of neighbor node information can be to merge the information of neighbor nodes into the current single node, thereby reflecting the association features mined through neighbor information on the single node.

[0083] For example, in graph computation using a graph neural network, each node has a representation vector. The initial representation vector is extracted from relevant business data. The aggregation of neighbor node information is the fusion of the neighbor node representation vectors and the current node's representation vector. For instance, the aggregation process of a node u's neighbor nodes at layer k can be represented as: g(u) k =∑W k [(wv) k-1 +b], where W k Let be the parameter matrix of layer k (which is also a parameter that needs to be determined in the graph learning process), v be the representation vector of a single neighbor node of node u in layer k-1, w be the weight of a single neighbor node in the aggregation process of node u, and b be a constant parameter. The fusion result is the calculation result, which can be used as the parameter for the next calculation round.

[0084] For example, in PageRank-based graph analysis algorithms, the information used for calculation at each node is its weight. This weight can be the node's degree (number of connected edges) or a value determined in other ways; no restrictions are placed here. The calculation for neighboring nodes involves aggregating their weights, such as summing them. This calculation result is the final result, which can be used as a parameter for the next round of calculation, or the weights can be further updated based on this result as parameters for the next round, such as updating the weights to...

[0085] Thus, after multiple computation cycles, although both the first and second parties perform local homomorphic ciphertext computation during the computation process, they fully utilize each other's graph data based on the second type of node, achieving joint privacy computation and improving the business effect of graph analysis effectiveness.

[0086] Reviewing the above process, in the privacy graph computation scenario jointly conducted by two parties, the first and second parties each hold local graph data. Considering that there are only a few common nodes during the computation process, the nodes in the graph data are classified into two categories: second-class nodes (common nodes) and first-class nodes (non-common nodes). To save communication volume, the overall architecture adopts a computation method where the first and second parties each compute using the homomorphic encryption of the other party's encryption key. For the second-class nodes, since the two parties may have different parameters used for computation, the common node parameter information of the two parties is synchronized in each computation cycle. This parameter information synchronization process is combined with the conversion of the privacy computation form, and finally exists in the form of ciphertext of the synchronized value, which is used by the first and second parties to perform homomorphic ciphertext computation locally. In this way, the communication volume can be reduced to the communication during the second-class node information synchronization process, effectively saving communication volume and greatly improving the efficiency of privacy graph computation between the two parties.

[0087] Through complexity analysis, the technical solution provided in this specification achieves a communication complexity of O(|V|) for a single iteration. Compared to conventional solutions where the communication complexity includes at least one term related to the number of edges |E|, the communication complexity of the solution provided in this specification is only related to the number of vertices |V|, significantly reducing the amount of communication required in practical applications. Experimental results show that on a graph with 100 million connected edges, this solution achieves an execution speed up to 6837 times faster than conventional two-party privacy graph analysis solutions such as GraphSC, and reduces the number of communication bytes to 1 / 29010.

[0088] According to another embodiment, a privacy graph computation apparatus is also provided, used for synchronizing parameters of a second type of node, which serves as a common node, during a single computation cycle in a joint graph computation process performed by a first party and a second party. This apparatus can be installed on any computer, device, or server with a certain computing power. Figure 6 As shown, a privacy graph calculation apparatus 600 according to one embodiment may include an acquisition unit 601 and a calculation unit 602.

[0089] In a single computation cycle of graph calculation:

[0090] The acquisition unit 601 can be configured to acquire the parameter ciphertext corresponding to the parameters of each node respectively. The parameter ciphertext is in the form of encryption by the second key provided by the second party. The parameter ciphertext of a single first-type node is determined locally. The parameter ciphertext of a single second-type node is determined by secure negotiation with the second party under the form of secret sharing and is securely converted into the synchronization value ciphertext in the form of local homomorphic encryption.

[0091] The computing unit 602 can be configured to use the parameter ciphertext of each node to perform homomorphic ciphertext calculations on the nodes in the first graph based on the corresponding parameters, so as to obtain the respective ciphertexts corresponding to each node.

[0092] In one embodiment: during the initial computation cycle, the first parameter value of the aforementioned single second-type node on the first party and the second parameter value on the second party are both in plaintext form; the acquisition unit 601 can be configured to negotiate with the second party to determine the encrypted parameter of the single second-type node according to a predetermined synchronization strategy in the following manner:

[0093] When the predetermined synchronization strategy is to take the maximum value or the minimum value, a secure comparison is performed with the second party in the form of secret sharing to determine the larger or smaller value of the first parameter value and the second parameter value as the synchronization value, and the first fragment of the synchronization value is obtained during the secure comparison process.

[0094] When the predetermined strategy is summation and averaging, the following secure calculation is performed with the second party: the first parameter value is split into the sum of two sub-values, and one sub-value of each of the first and second parameter values ​​is exchanged with the second party; the sub-values ​​of the first parameter value retained locally and the sub-values ​​of the second parameter value obtained from the second party are processed according to the predetermined strategy to obtain the first fragment of the synchronization value.

[0095] In one embodiment, during a non-initial computation cycle, the first party holds the encrypted first parameter value of the aforementioned single second-type node, and the second party holds the encrypted second parameter value of the aforementioned single second-type node.

[0096] The acquisition unit 601 can be configured to negotiate with the second party to determine the ciphertext of the parameters of a single second-type node in accordance with a predetermined synchronization strategy in the following manner:

[0097] In collaboration with a second party, the ciphertext of the first parameter value and the ciphertext of the second parameter value are each converted into plaintext data in a secret sharing format.

[0098] The first fragment of the synchronization value is obtained by using plaintext data in a secret sharing format and performing secure calculations with a second party based on a predetermined synchronization strategy.

[0099] It is worth noting that, Figure 6 The device 600 shown and Figure 4 Corresponding to the described method, Figure 4 The corresponding descriptions in the method embodiments also apply to the device 600, and will not be repeated here.

[0100] According to another embodiment, a computer-readable storage medium is also provided, on which a computer program is stored, which, when executed in a computer, causes the computer to perform a combination Figure 4 , Figure 5 The methods described above.

[0101] According to another embodiment, a computing device is also provided, including a memory and a processor, wherein the memory stores executable code, and when the processor executes the executable code, it implements a combination... Figure 4 , Figure 5 The methods described above.

[0102] Those skilled in the art will recognize that the functions described in the embodiments of this specification in one or more of the above examples can be implemented using hardware, software, firmware, or any combination thereof. When implemented in software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or code on a computer-readable medium.

[0103] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of the technical concept in this specification. It should be understood that the above description is only a specific embodiment of the technical concept in this specification and is not intended to limit the scope of protection of the technical concept in this specification. Any modifications, equivalent substitutions, improvements, etc., made on the basis of the technical solutions of the embodiments in this specification should be included within the scope of protection of the technical concept in this specification.

Claims

1. A method for privacy graph computation, used for a first party and a second party to jointly perform security graph computation, the first party holding a first graph, the nodes in the first graph including second-type nodes shared with a second graph held by the second party, and first-type nodes other than the second-type nodes, in a single computation cycle of the graph computation, the method comprising: The parameter ciphertext corresponding to the parameters of each node is obtained respectively. The parameter ciphertext is encrypted with a second key provided by a second party. The parameter ciphertext of a single first-type node is determined locally. The parameter ciphertext of a single second-type node is determined by secure negotiation with the second party under secret sharing and is securely converted into a synchronization value ciphertext in local homomorphic encryption form. Using the ciphertext parameters of each node, homomorphic ciphertext calculations are performed on the nodes in the first graph based on their respective parameters to obtain the ciphertext corresponding to each node.

2. The method of claim 1, wherein: In the initial computation cycle, the ciphertext of the parameters of a single first-class node is determined by encrypting the parameters of the single first-class node using a second key; In non-initial computation cycles, the parameter ciphertext of a single Class 1 node is determined by the ciphertext obtained from the computation of the previous computation cycle.

3. The method as described in claim 1, wherein, During the initial calculation period, the first parameter value of the aforementioned single second-type node on the first side and the second parameter value on the second side are both in plaintext form; The encrypted parameters of a single second-type node are determined through negotiation with the second party according to a predetermined synchronization strategy in the following manner: When the predetermined synchronization strategy is to take the maximum value or the minimum value, a secure comparison is performed with the second party in the form of secret sharing to determine the larger or smaller value of the first parameter value and the second parameter value as the synchronization value, and the first fragment of the synchronization value is obtained during the secure comparison process. When the predetermined synchronization strategy is summation and averaging, the following secure calculation is performed with the second party: the first parameter value is split into the sum of two sub-values, and one sub-value of the first parameter value and the second parameter value are exchanged with the second party. The sub-values ​​of the first parameter value retained locally and the sub-values ​​of the second parameter value obtained from the second party are processed according to the predetermined synchronization strategy to obtain the first fragment of the synchronization value.

4. The method of claim 1, wherein, In non-initial computation cycles, the first party holds the encrypted first parameter value of the aforementioned single second-type node, and the second party holds the encrypted second parameter value of the aforementioned single second-type node. The ciphertext of the parameters of the individual second-type node is determined through negotiation with the second party in the following manner: In conjunction with the second party, the encrypted first parameter value and the encrypted second parameter value are each converted into plaintext data in a secret sharing format. The first fragment of the synchronization value is obtained by using plaintext data in a secret sharing format and a second party to perform secure calculations based on a predetermined synchronization strategy.

5. The method of claim 1, wherein, For the first node in the first graph, the calculation includes: The parameter ciphertexts of the first node and each of its neighboring nodes are fused using one of the following methods: summation, averaging, taking the maximum value, taking the minimum value, taking the median, or weighted summation.

6. An apparatus for privacy graph computation, used for a first party and a second party to jointly perform security graph computation, the first party holding a first graph, the nodes in the first graph including second-type nodes shared with a second graph held by the second party, and first-type nodes other than the second-type nodes; the apparatus comprising: Acquisition unit, calculation unit; In a single computation cycle of graph calculation: The acquisition unit is configured to acquire the parameter ciphertext corresponding to the parameters of each node respectively, wherein the parameter ciphertext is in the form of encryption by the second key provided by the second party, the parameter ciphertext of a single first-type node is determined locally, and the parameter ciphertext of a single second-type node is determined by secure negotiation with the second party in the form of secret sharing, and is securely converted into the synchronization value ciphertext in the form of local homomorphic encryption. The computing unit is configured to use the parameter ciphertext of each node to perform homomorphic ciphertext calculations on the nodes in the first graph based on the corresponding parameters, so as to obtain the respective ciphertexts corresponding to each node.

7. The apparatus of claim 6, wherein: During the initial calculation period, the first parameter value of the aforementioned single second-type node on the first side and the second parameter value on the second side are both in plaintext form; The acquisition unit is configured to negotiate with the second party to determine the ciphertext of the parameters of a single second-type node in accordance with a predetermined synchronization strategy in the following manner: When the predetermined synchronization strategy is to take the maximum value or the minimum value, a secure comparison is performed with the second party in the form of secret sharing to determine the larger or smaller value of the first parameter value and the second parameter value as the synchronization value, and the first fragment of the synchronization value is obtained during the secure comparison process. When the predetermined synchronization strategy is summation and averaging, the following secure calculation is performed with the second party: the first parameter value is split into the sum of two sub-values, and one sub-value of the first parameter value and the second parameter value are exchanged with the second party. The sub-values ​​of the first parameter value retained locally and the sub-values ​​of the second parameter value obtained from the second party are processed according to the predetermined synchronization strategy to obtain the first fragment of the synchronization value.

8. The apparatus of claim 6, wherein, In non-initial computation cycles, the first party holds the encrypted first parameter value of the aforementioned single second-type node, and the second party holds the encrypted second parameter value of the aforementioned single second-type node. The acquisition unit is configured to negotiate with the second party to determine the ciphertext of the parameters of a single second-type node in accordance with a predetermined synchronization strategy in the following manner: In conjunction with the second party, the encrypted first parameter value and the encrypted second parameter value are each converted into plaintext data in a secret sharing format. The first fragment of the synchronization value is obtained by using plaintext data in a secret sharing format and a second party to perform secure calculations based on a predetermined synchronization strategy.

9. A computer-readable storage medium having a computer program stored thereon, which, when executed in a computer, causes the computer to perform the method of any one of claims 1-5.

10. A computing device, comprising a memory and a processor, characterized in that, The memory stores executable code, and when the processor executes the executable code, it implements the method of any one of claims 1-5.

Images