A multi-party secure subgraph matching method based on star decomposition and topology reuse

Abstract

The application discloses a multi-party secure subgraph matching method based on star decomposition and topology reuse, which utilizes a star decomposition strategy to analyze the topology of a query graph, converts the complex query graph into a star substructure set with minimized scale through greedy coverage and load balancing optimization, executes calculation by using a multi-party secure connection protocol, and introduces a topology reuse mechanism to identify a common topology structure, directly covers isomorphic small star structures by using the intermediate matching result of a large star structure, and avoids redundant calculation on the overlapping structure; the connection order is determined based on a greedy strategy, and a secure symmetry verification protocol is introduced to identify and eliminate redundant matching due to the self-isomorphism of the query graph in a ciphertext state. The application can significantly reduce the number of expensive secure connection operations in multi-party secure calculation by optimizing the query architecture under the premise of strictly protecting the graph structure privacy, and can directly obtain accurate and non-redundant matching results without plaintext post-processing.

Description

Technical Field

[0001] This invention belongs to the field of information security and privacy computing technology, specifically relating to a multi-party secure subgraph matching method based on star decomposition and topology reuse. Background Technology

[0002] Graph computing has become a core tool for unlocking the value of relationships within massive datasets, and is widely applied in fields such as social network analysis, bioinformatics, and knowledge graph reasoning. Subgraph matching, which aims to accurately retrieve isomorphic substructures from large-scale graph data, is a crucial foundational query primitive. However, real-world graph data often contains sensitive privacy information (such as social relationships and communication records), making it difficult for data owners to directly outsource plaintext analysis, significantly limiting the application scope of cloud-based graph computing services.

[0003] Secure Multi-Party Computation (MPC) technology, based on secret sharing, achieves "data usable but not visible" by dividing data into fragments and conducting collaborative computation among mutually untrusted servers. It is considered an ideal solution to outsourcing privacy issues. In the MPC architecture, the graph structure is mapped to a relational table, and the subgraph matching process is transformed into a series of secure connection operations executed in a ciphertext state.

[0004] Although MPC provides strict information-theoretic security, its special execution mechanism leads to a severe efficiency bottleneck: each secure connection operation is accompanied by high communication rounds and computational overhead, and a large number of dummy cells must be filled to hide the size of intermediate results, resulting in ciphertext computation costs far exceeding those of traditional plaintext environments.

[0005] In existing technologies, one type of solution mainly uses structural encryption or encrypted indexing to support privacy-preserving subgraph queries. These methods can improve query efficiency by utilizing certain structural or feature information during the candidate selection stage. However, their processing still primarily focuses on candidate generation and post-processing filtering, and they haven't systematically optimized the query graph decomposition method or substructure computation reuse to address the high overhead of secure connections and sensitivity to connection rounds in multi-party secure computation environments. Another type of solution mainly uses graph anonymization or structural perturbation to achieve privacy-preserving subgraph matching in outsourcing scenarios. These methods can reduce the risk of direct identification of node identities or local structures to some extent. However, since the server generates candidate results, subsequent verification and filtering still rely on the data requester or data owner for plaintext verification. When the query graph has complex connections or strong self-similar symmetry, these methods typically require enumerating a large number of candidate permutations, easily leading to massive intermediate results and redundant matching.

[0006] In summary, the shortcomings of existing technologies are mainly reflected in the following two aspects: First, most existing privacy protection schemes follow the general query planning strategies of traditional databases (such as simple edge decomposition or left deep tree join order), failing to perform in-depth optimization of the query graph to address the high communication cost characteristics of MPC. This coarse decomposition strategy often leads to an excessive number of join operations and improper control of the size of intermediate results, causing the overall computational latency to increase exponentially with the increase of query complexity.

[0007] Secondly, existing methods fail to effectively utilize the self-similarity and symmetry inherent in graph topologies. When processing complex queries, graphs often contain multiple isomorphic substructures. Existing techniques typically treat matching each substructure as an independent computational task, leading to redundant computation of common topologies. Furthermore, the inherent self-isomorphic symmetry of graph structures (such as fully connected graphs or ring structures) can cause a severe result explosion problem in encrypted computation. The system generates a large number of redundant matching results that differ only in the order of nodes but essentially represent the same subgraph. This redundant data not only consumes a significant amount of storage and network bandwidth but also often forces data requesters to perform tedious plaintext filtering after decryption, severely limiting the system's practicality and scalability.

[0008] Therefore, how to design a topology-aware query optimization mechanism under a multi-party secure computation framework, and minimize the number of secure connections and eliminate redundant computations through structural decomposition, reuse of intermediate results and elimination of ciphertext symmetry, is a key technical problem that urgently needs to be solved to achieve efficient privacy-preserving subgraph matching. Summary of the Invention

[0009] To address the shortcomings of existing technologies, particularly the problems of high secure connection overhead, lack of query topology optimization, and severe result redundancy in multi-party secure computation environments, this invention provides a multi-party secure subgraph matching method based on star decomposition and topology reuse. By reconstructing the query processing architecture, it fully utilizes the topological features and self-similarity of graph data, significantly reducing the number of expensive ciphertext connections and eliminating computational redundancy while strictly protecting data privacy, thereby improving the execution efficiency of privacy-preserving queries on large-scale graph data.

[0010] A multi-party secure subgraph matching method based on star decomposition and topology reuse includes the following steps: (1) The query graph topology is parsed using the star decomposition strategy. Through greedy coverage and load balancing optimization, the complex query graph is transformed into a set of star substructures with the maximum star size minimized. (2) The computation is performed using a multi-party secure connection protocol and a topology reuse mechanism is introduced. The largest star substructure in the set is selected as the computation object, and its intermediate matching result is used to directly cover the isomorphic small star substructure in the set. (3) Assemble the matching results of each star substructure based on a greedy strategy, and use a symmetry verification protocol to remove redundant tuples to generate the final matching result.

[0011] Furthermore, the specific implementation of step (1) is as follows: A1. With the goal of quickly covering all query edges, the vertex with the largest current degree is repeatedly selected as the center in the subgraph formed by the remaining edges, and the star substructure containing all its associated edges is extracted to form the initial set of star substructures. A2. With the goal of minimizing the maximum star shape size, iterative edge migration is performed on the initial set of star substructures, migrating the corresponding edges from the maximum star substructure to the smaller star substructure, thereby reducing the size of the maximum star substructure.

[0012] Furthermore, the specific implementation process of step A1 is as follows: S11: Initialize the decomposition state and construct an empty set of star-shaped substructures. SQ And assign the original edge set of the query graph to the remaining edge set. , as the initial set of edges to be covered; S12: In the case of The degree of each vertex in the resulting subgraph is recalculated, and the vertex with the highest degree is selected as the center node. u ; S13: Building with u It is the root and contains it in Add the star substructure of all associated edges to the star substructure. SQ In, and from these associated edges Remove from; S14: Detection If the value is not empty, return to step S12 to continue decomposition; otherwise, proceed to the balancing stage.

[0013] Furthermore, the specific implementation process of step A2 is as follows: S15: Initiate the iterative balancing optimization process, initialize the optimization state flag to false, and scan the current set. SQ Identify the largest star-shaped substructure containing the most edges. q max And record its center node as u r ; S16: Traversal Search q max leaf nodes in v And the leaf node v for SQ Another star-shaped substructure qv The central node; S17: For node pairs that meet the conditions ( u r , v Perform load difference detection and determine... q max Size and q v If the size difference is greater than a preset threshold, then proceed to step S18. S18: Transfer node pairs ( u r , v The edge of ) from q max Migrate to q v Set the optimization status flag to true and stop the current traversal; S19: Check the current optimization state flag. If it is true, return to step S15 and iterate again. If it is false, output the final star-shaped substructure set. SQ .

[0014] Furthermore, the specific implementation of step (2) is as follows: B1. First, identify the largest star substructure and its central node, and initialize the star matching result vector and intermediate result container; then, use the multi-party secure sorting protocol to sort the ciphertext edge matching table globally with the central node as the sorting key, so that it is arranged in a logically ordered manner according to the predefined interval and start the iterative incremental matching process. B2. Based on the number of edges already processed i For indexing, iterate over each edge of the largest star substructure: in each round, first construct a semantically consistent right operand table by renaming attributes, then perform bucketed parallel encrypted joins based on the interval characteristics of the ordered table, and finally aggregate to generate the current size. i Partial matching of intermediate results; then immediately scan the set to see if there are any items of the same size. i If a small star-shaped substructure exists, the intermediate result is directly assigned to the corresponding result vector, saving the need for independent connection calculations.

[0015] Furthermore, the specific implementation process of step B1 is as follows: S21: Initialize the matching environment in the star-shaped substructure set. SQ The largest star-shaped substructure was identified in the middle. q max and its central node u r And initialize the vector used to store the star-shaped matching results of each size. ; S22: Perform data rearrangement using a multi-party secure ordering protocol. u r The encrypted edge matching table is sorted using the sort key, so that its tuples are arranged in an ordered manner in physical storage according to the predefined interval partitioning logic, forming an ordered table; S23: Initialize the intermediate result container and target... q max For each edge in the process, an iterative incremental matching process is initiated, and the number of edges processed in the current iteration is recorded as follows: i .

[0016] Furthermore, the specific implementation process of step B2 is as follows: S24: In each iteration, perform attribute renaming operations on the ordered table according to the currently processed edges to construct a right operand table that is semantically consistent with the current connection pattern; S25: Utilize the bucket join algorithm in the multi-party secure connection protocol to... u r Using the common join key, the data is divided into multiple independent logical buckets by leveraging the range characteristics of the ordered table, and the encrypted join within the buckets is performed in parallel between the intermediate result container and the right operand table. S26: Aggregate the connection outputs of each logic bucket, update the intermediate result container, where the intermediate result represents the current size of... i The star topology matches all partial instances in the original graph data; S27: Perform topology reuse detection, scanning the set of star-shaped substructures. SQ Determine if there exists a size equal to i If it is a small star-shaped substructure, then proceed to step S28; S28: Perform a result overwrite operation, directly assigning the current intermediate result to the vector. The corresponding elements are used to skip the independent connection calculations for these small star-shaped substructures; S29: Repeat steps S24 to S28 until... q max After all edges have been processed, the output contains a set. SQ The vector of matching results for all star-shaped substructures in the vector .

[0017] Furthermore, the specific implementation of step (3) is as follows: C1. Treat the star-shaped substructure set as the unit to be merged, start a greedy iterative loop, traverse all possible substructure pairs in each round, use the cost estimation function to predict the size of the merged result, select the pair with the smallest estimated value as the best merge object; then read the corresponding ciphertext table from the result vector or temporary table, perform a multi-party secure connection to generate a new merged substructure, and replace it back into the set, repeat this process until only one global substructure and its matching ciphertext table remain in the set; C2. After obtaining the unique globally matching ciphertext table, initiate the symmetry verification process: read the symmetric vertex grouping information pre-generated based on the automorphism of the query graph, and divide the attribute values ​​of each ciphertext tuple into sub-vectors according to the group; use the multi-party secure comparison module to verify whether the elements in each sub-vector in the tuple satisfy the predefined partial order relation, and if not, directly mark the entire tuple as invalid; finally, filter the ciphertext table according to the validity bit and remove all redundant tuples generated by symmetry.

[0018] Furthermore, the specific implementation process of step C1 is as follows: S31: Initialize the assembly state, and set up the star-shaped substructures. SQ Define the current set to be merged, and set the minimum connection cost. b min Initialize to infinity; S32: Start a greedy iterative loop to check the current set. SQ If the number of substructures is equal to 1, proceed to step C2 to enter the verification stage; if the number is greater than 1, continue to execute the subsequent steps. S33: Traversing a set SQ For all possible substructure pairs, and for each substructure pair, calculate the estimated size of the result after performing a secure connection using a preset cost estimation function, based on the size of its corresponding ciphertext result table and the distribution of the join keys. b This estimate reflects the communication load of the next round of MPC operations; S34: Execute the optimal selection strategy, comparing the estimated values ​​of each substructure pair during the traversal. b ,like b < b min Then update b min = b And record the corresponding substructure pair as the current best merge object ( q a , q b ); S35: After determining the optimal merge target, parse the substructure. q a and qb The type origin, if the substructure belongs to the star-shaped unit of the initial decomposition, then from the vector The corresponding ciphertext table is indexed and read; if the substructure belongs to the intermediate result generated in the previous round, the temporary ciphertext table in memory is read directly. S36: Using a multi-party secure connection protocol, perform a join operation on the two read ciphertext tables to generate a new merged substructure and its corresponding ciphertext matching result, and mark the result as a temporary ciphertext table; S37: Update assembly state from set SQ Remove substructures that have already participated in the connection. q a and q b Add the newly generated merged substructure SQ In the middle, reset the least connection cost b min Then return to step S32 to begin the next iteration.

[0019] Furthermore, the specific implementation process of step C2 is as follows: S38: When set SQ When only one substructure remains, the symmetry verification process is initiated, and the symmetry vertex grouping information pre-calculated based on the automorphism property of the query graph is read. S39: Ciphertext table corresponding to this unique substructure Each ciphertext tuple in the tuple is divided into several corresponding attribute sub-vectors based on the symmetric vertex grouping information. S310: Construct a multi-party secure comparison module to verify, in ciphertext state, whether the internal elements of each attribute subvector strictly follow a predefined monotonic partial order relationship (such as ascending order) to break the symmetry. S311: Aggregate the verification results. If any attribute sub-vector violates the partial order relation, an invalid flag is generated, and the validity bit of the ciphertext tuple is updated by a logical OR operation. S312: Pair the ciphertext table with validity bits Perform logical filtering to remove all redundant tuples marked as invalid, and output accurate, non-redundant subgraph matching results.

[0020] A computer device includes a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the above-described multi-party secure subgraph matching method based on star decomposition and topology reuse.

[0021] A computer-readable storage medium storing a computer program, which, when executed by a processor, implements the above-described multi-party secure subgraph matching method based on star decomposition and topology reuse.

[0022] This invention first uses a star-structure decomposition strategy to parse the query graph topology, and then optimizes it through greedy covering and load balancing to transform the complex query graph into a set of star-structure substructures with the smallest maximum star size, thereby reducing the connection depth of the query. Next, a topology reuse mechanism is introduced in the matching phase, selecting the largest star-structure substructure in the set as the primary computation object. During the execution of multi-party secure connections, the generated large star intermediate results directly cover isomorphic small star structures, avoiding repeated computations on common topologies. Finally, the matching results of each star substructure are assembled based on a greedy strategy, and a symmetry verification protocol is introduced to identify and eliminate redundant matches caused by the self-isomorphism of the query graph in encrypted form, reconstructing and generating the final accurate subgraph matching set. Therefore, based on the above technical solution, this invention has the following beneficial technical effects: 1. This invention designs a star decomposition strategy that combines greedy coverage and load balancing. By iteratively optimizing the size of the largest star substructure, the complex query graph is transformed into a star set with the smallest scale, which effectively reduces the depth and communication cost of subsequent secure connection operations.

[0023] 2. This invention introduces a topology reuse mechanism in a encrypted environment, which makes full use of the inclusion property of star topology. It uses the intermediate calculation results of the largest star substructure to directly map and cover the isomorphic small star substructure, avoiding repeated independent calculations of common topology structures, thereby greatly reducing unnecessary computing power consumption in an encrypted environment.

[0024] 3. This invention proposes an assembly process based on a greedy strategy and improves the execution logic of traditional secure connections by utilizing a ciphertext symmetry verification protocol. It can identify and eliminate redundant matching results caused by the automorphism of the query graph online, effectively solving the problem of intermediate result explosion in multi-party secure computation. It can directly output accurate and non-redundant matching sets without additional plaintext filtering, thereby significantly improving the overall efficiency and practicality of large-scale graph data query while ensuring strict privacy and security. Attached Figure Description

[0025] Figure 1 This is a schematic diagram of the multi-party secure subgraph matching method based on star decomposition and topology reuse of the present invention.

[0026] Figure 2 This is a schematic diagram of the algorithm for star-shaped decomposition query graph topology in this invention.

[0027] Figure 3 This is a schematic diagram of the star-shaped matching algorithm based on topology reuse in this invention.

[0028] Figure 4 This is a schematic diagram of the algorithm for assembling the various star-shaped substructures in this invention. Detailed Implementation

[0029] To describe the present invention in more detail, the technical solution of the present invention will be described in detail below with reference to the accompanying drawings and specific embodiments.

[0030] This embodiment uses the scenario of identifying abnormal user relationships on a social platform as an example. The social platform, as the data owner, holds a sensitive user relationship network composed of user accounts and their social associations. The data analyst wants to query whether specific abnormal relationship patterns exist within this network without obtaining plaintext relationship data; for example, a core account simultaneously associated with multiple suspicious accounts, or multiple accounts forming a closed-loop association structure. Therefore, the data owner converts the user relationship network and secretly shares it with multiple non-colluding servers, which then collaboratively complete the matching calculation in encrypted form. In this scenario, the user relationship network corresponds to the original graph data, user accounts correspond to nodes, and social associations between users correspond to edges. The abnormal relationship patterns submitted by the data analyst correspond to the query graph, where the local pattern of a core account connecting multiple associated accounts corresponds to a star-shaped substructure. The actual social association records in the user relationship network are preprocessed to form an edge matching table, and each record in the edge matching table corresponds to a user association edge in the data graph. Through this method, user combinations that satisfy the target abnormal relationship pattern can be output without disclosing user relationship data; such as... Figure 1 As shown, the specific implementation process of this embodiment is as follows: (1) The query graph topology is parsed using the star decomposition strategy. Through greedy coverage and load balancing optimization, the complex query graph is transformed into a set of star substructures with the maximum star size minimized.

[0031] This step transforms an arbitrarily complex query graph into a set of star-shaped substructures covering the entire graph's edge set using an optimized graph traversal algorithm. First, a greedy covering based on remaining degree is performed to cover all edges with the minimum number of stars, reducing the number of rounds required for subsequent join operations. Then, a load balancing optimization based on the Min-Max principle is performed, dynamically migrating edge weights between adjacent stars to minimize the size of the largest star-shaped substructure in the set. This optimization significantly reduces the worst-case computational complexity and communication overhead of MPC bucket joins, laying the topological foundation for subsequent safe matching. The specific implementation of this step may include the following sub-steps: S11: Initialize the decomposition state and construct an empty set of star-shaped substructures. And query graph The original edge set is assigned to the remaining edge set. , as the initial set of edges to be covered.

[0032] Specifically, the system receives the query graph Introducing temporary variables Complete storage of the original edge set and the result set Initialize to empty. This operation ensures that the decomposition process starts with the full graph edge set, and subsequent operations will be based on it. The state changes are used to track the edge coverage, ensuring that the final result covers all the topological structures of the query graph without omission.

[0033] S12: In the set of remaining edges In the resulting subgraph, the vertex degree is recalculated, and the vertex with the highest current degree is selected. As the central node.

[0034] Specifically, in each round of decomposition iteration, for the remaining edge set The degree of each vertex in the induced current subgraph is counted. By selecting the vertex with the highest current degree as the center, the newly generated star substructure can cover as many remaining edges as possible in a single iteration, thereby effectively suppressing the total number of star substructures generated in the final process.

[0035] S13: Construct a system with a central node For the root, contained in Star topology with all associated edges Add it to the set and the corresponding edge from Removed from the middle.

[0036] Specifically, based on the selected central node Identify All of the above Construct a star topology using directly connected edges and their corresponding neighbor nodes. And save Then, a state update is performed, removing these edges from... Physical deletion is performed to ensure that each edge has a unique affiliation in the final decomposition set, thus achieving non-overlapping partitioning of the edge set of the query graph.

[0037] S14: Detect the remaining edge set If the value is not empty, return to step S12 to continue decomposition; otherwise, proceed to the balancing stage.

[0038] Specifically, through testing The greedy decomposition process is controlled by the state of the edges; as long as there are uncovered edges, the decomposition loop continues; once an uncovered edge appears, the decomposition loop ends. An empty value indicates that all edges have been allocated, the greedy phase has ended, and the algorithm automatically transitions to the subsequent load balancing phase to address the issue of excessively large maximum star topology size that may result from the greedy strategy.

[0039] S15: Initiate the iterative balancing optimization process and mark the optimization status. Initialize to false, then scan the current set. Identify the largest star-shaped substructure containing the most edges. And record its central node. .

[0040] Specifically, once the load balancing phase begins, the primary task is to pinpoint the current performance bottleneck by traversing the collection. The largest star-shaped substructure is determined based on the number of edges it contains. The size of this structure directly determines the maximum cost of subsequent secure connections, and therefore it is the primary target for optimization.

[0041] S16: Traversal leaf nodes in the set, find those that are also part of the set Another star-shaped substructure leaf nodes of the central node .

[0042] Specifically, this step aims to explore optimization possibilities by utilizing the adjacency relationships between star topologies. a leaf node It is exactly another star shape The center of the star indicates that the two star topologies are topologically adjacent. This structural feature allows for connections... and The edges are transferred between the two star topologies, providing operational paths for adjusting load distribution.

[0043] S17: For node pairs that meet the above conditions, perform load difference detection to determine the star substructure. Size (i.e., number of edges) and target star substructure Does the size difference exceed a preset threshold of 1? .

[0044] Specifically, a rigorous migration benefit assessment should be conducted only if the source star type The size is significantly larger than the target star shape Edge migration can effectively reduce the maximum load only when the difference is greater than 1; if the difference is insufficient, the migration operation may cause... If it becomes a new and larger bottleneck or fails to improve the current situation, this threshold determination ensures the monotonicity and effectiveness of the optimization direction.

[0045] S18: If the condition is met, The edge from Migrate to , will optimize state flag Set to true and stop the current iteration.

[0046] Specifically, perform the actual topology adjustments: The ownership of the edge from Transfer to This directly reduces the size of the largest star. Once a migration occurs, the overall load distribution of the set changes, the optimization flag is immediately updated, and the current traversal is skipped to allow for the next round of evaluation based on the new set state, preventing erroneous operations based on outdated information.

[0047] S19: Check optimization status flags If true, return to step S15 and iterate again; if false, output the final set of star-shaped substructures. .

[0048] Specifically, this step determines whether the algorithm has converged by optimizing the marker: if the marker is true, it means that there is an effective edge migration in this round, and we need to return to step S15 to continue searching for optimization space; if the marker is false, it means that it is currently impossible to further reduce the size of the maximum star shape through edge migration, the set has reached a local optimal equilibrium state, the algorithm terminates and outputs the final optimized result. For use in subsequent matching steps.

[0049] like Figure 2 As shown, the query graph is first decomposed into three star-shaped substructures through greedy covering. , and ,in Represents star-shaped substructure The number of edges contained in the initial decomposition result. , , ,illustrate This is currently the largest star substructure, larger than other star substructures; subsequently, load balancing optimization is performed. The red markers in the diagram represent the migrated edges and their associated nodes. Move one edge in the middle to the adjacent one. Thus, the optimized star-shaped substructure is obtained. , and After optimization , , The maximum star shape size is reduced from 4 to 3, making the size of each star shape substructure more balanced, which is beneficial to reducing the maximum connection depth in subsequent ciphertext star shape matching.

[0050] (2) The computation is performed using a multi-party secure connection protocol and a topology reuse mechanism is introduced. The largest star substructure in the set is selected as the computation object, and its intermediate matching result is used to directly cover the isomorphic small star structure in the set.

[0051] To address the significant overhead of independently computing each subquery, this step proposes a topology reuse strategy based on maximum star schema coverage. This strategy selects only the largest star schema substructure in the decomposition set as the primary computation object and performs iterative multi-party secure connections on it. During this process, as the connection depth increases, the system generates a series of intermediate results. These intermediate results naturally correspond to the matching results of all smaller star schema substructures. By directly mapping these intermediate results to isomorphic smaller star schemas, independent computation of all other star schema substructures in the decomposition set is avoided. This achieves full-coverage reuse with a single computation, significantly reducing the total computation and communication rounds in encrypted environments. The specific implementation of this step may include the following sub-steps: S21: Initialize the matching environment in the star-shaped substructure set. The size of the identification is The largest star substructure and its central node And initialize the vector used to store the star-shaped matching results of each size. .

[0052] Specifically, the system scans the set of star-shaped substructures. Lock the star topology with the most edges ;because It contains all the smaller star-shaped structures that can exist in the set topologically, therefore it is the only object that requires an explicit join operation; vector Created as an empty container for subsequent storage from Various star-shaped matching results were extracted incidentally during the calculation process.

[0053] S22: Perform data rearrangement using a multi-party secure ordering protocol, with the central node as the core. Matching table of ciphertext edges for sorting keys Sort the tuples so that they are logically ordered in physical storage according to a predefined interval partitioning, forming an ordered table. .

[0054] Specifically, in MPC, to avoid the performance disaster caused by the full table Cartesian product, data needs to be bucketed, using a star-shaped central node. By inadvertently sorting the edge table of key-pair encryption, tuples with the same connection key value are stored physically contiguously. This allows subsequent operations to divide the data into several independent logical buckets using predefined interval information, creating conditions for parallel processing.

[0055] S23: Initialize intermediate result container And targeting the largest star substructure For each edge, an iterative incremental matching process is initiated, and the number of edges processed in the current iteration is recorded as follows. .

[0056] Specifically, containers Initially, store the matching result of the first edge; subsequent loops will introduce it one by one. The remaining edges, variables The dynamic indicator shows the size of the currently generated star topology, i.e., the number of leaf nodes it contains.

[0057] S24: In each iteration, based on the edge being processed... For ordered lists Perform an attribute renaming operation to build a right operand table that is semantically consistent with the current join pattern.

[0058] Specifically, since the edge table is generic, but each new edge is created when constructing a star topology, it is based on... This is connected from the center. Therefore, the attribute mapping needs to be adjusted at the ciphertext metadata level to ensure that the column representing the "source node" in the right operand table matches the intermediate result container. The central node in Alignment satisfies the semantic requirements of equi-joins.

[0059] S25: Utilize the bucket join algorithm in the multi-party secure connection protocol to... Using the common join key, the data is divided into multiple independent logical buckets based on the range characteristics of ordered tables, and then stored in the intermediate result container. Perform a bucket-based ciphertext join in parallel with the right operand table.

[0060] Specifically, instead of directly performing a large table join, the sorting interval described in step S32 is used to... The right operand table is divided into corresponding logical buckets. Since the data range within each bucket is independent, multiple servers can execute secure connections in parallel at the bucket level, and only need to perform obfuscation and computation within the bucket. This divide-and-conquer strategy greatly reduces the time complexity of a single connection.

[0061] S26: Aggregate the connection outputs of each logic bucket and update the intermediate result container. The intermediate results characterize the current size as The star topology matches all partial instances in the original graph data.

[0062] S27: Perform topology reuse detection, scanning the set of star-shaped substructures. Determine if there is a size equal to the current iteration size Smaller star-shaped substructure .

[0063] Specifically, in calculation During the process, after each round of connection is completed, the current In fact, it is a complete one with a size of The system checks the set to be solved for the star-shaped matching results. We will then examine whether there are other star-shaped substructures that also require this size for a matching result.

[0064] S28: If a substructure that satisfies the condition exists, perform a result overwrite operation and directly assign the current ciphertext intermediate result to the result vector. The corresponding element This allows skipping the independent connection calculations for the smaller star-shaped substructure.

[0065] Specifically, once a match is detected, the system will directly... The reference or copy is saved to the result vector, as those of size . small star The final result. This means that these small star systems no longer need to initiate any connection processes separately, and their computational cost is completely amortized to [the system / organization]. In the calculation, zero-cost computation was achieved.

[0066] S29: Repeat steps S24 to S28 until... After all edges have been processed, the output contains a set. The vector of matching results for all star-shaped substructures in the vector .

[0067] like Figure 3 As shown, the star schema matching process uses the central node of the star schema as the common connection key. The red nodes in the diagram represent the connection keys used in each round of connections, and the black nodes represent the leaf nodes in the star schema substructures. This indicates a secure multi-party connection operation performed in encrypted form. The server first joins the single-edge matching results to obtain a star-shaped matching result of size 2. Subsequently, new edge matching results were introduced using the same connection key, resulting in a star-shaped matching result of size 3. ,in This indicates that the corresponding results are stored in a secret shared format, and the background-colored area represents the intermediate star-shaped results that have already been generated and can be reused. Through this process, intermediate results generated during the matching of larger star-shaped structures can be directly used as the matching results of smaller star-shaped substructures, thereby avoiding the repeated execution of independent ciphertext join calculations.

[0068] (3) Assemble the matching results of each star substructure based on a greedy strategy, and use a symmetry verification protocol to remove redundant results to generate the final matching set.

[0069] This step reconstructs the scattered star-shaped substructure matching results into a complete query graph matching set. Addressing the significant performance impact of intermediate result size in MPC environments, this invention abandons fixed connection orders and adopts a greedy assembly strategy based on cost estimation. It dynamically selects the merging path that produces the smallest intermediate results after each round of connections, thereby minimizing overhead. Furthermore, addressing the common self-similar symmetry problem in graph queries, a ciphertext symmetry verification protocol is used. This protocol does not rely on the data owner's participation and directly introduces monotonic partial order constraints during ciphertext computation, forcibly breaking symmetry. This identifies and eliminates all redundant matches generated by permutations and combinations before the output results are released, ensuring the accuracy and compactness of the final result. The specific implementation of this step may include the following sub-steps: S31: Initialize the assembly state, which will contain the set of all matched star substructures. Define the current set to be merged, and set the minimum connection cost. Initialize to infinity.

[0070] Specifically, each element in the star-shaped substructure set represents an independent star-shaped subquery and its corresponding encrypted result table; the initialization process sets the starting state for the greedy search, where... The estimated cost used to track the current optimal connection path in subsequent iterations.

[0071] S32: Start a greedy iterative loop to check the current set. If the number of substructures is equal to 1, then proceed to step S38 to enter the verification stage; if the number is greater than 1, then continue to execute the subsequent steps.

[0072] Specifically, through monitoring collections The base number is used to control the assembly process, when At this time, it means that the query graph is still divided into multiple local fragments, and the join operation needs to continue; when When all the fragments have been successfully pieced together into a complete query graph structure, the assembly phase ends, and the process moves into the symmetry verification phase.

[0073] S33: Traversing a set All possible substructure pairs For each pair of substructures, based on the size of its corresponding ciphertext result table and the distribution of the join keys, a pre-defined cost estimation function is used to calculate the estimated size of the result after performing a secure join. .

[0074] Specifically, the algorithm exhaustively evaluates all feasible merging schemes. To avoid performing expensive actual joins, it uses metadata as input to a cost estimation function to predict the size of the intermediate result table generated after joining the two substructures. This directly reflects the communication load of the next round of MPC operations.

[0075] S34: Execute the optimal selection strategy, comparing the estimated values ​​of each pair of substructures during the traversal. ,like Then update the minimum connection cost. And record the current best merged object pair. .

[0076] Specifically, this is the core of the greedy strategy's decision-making process. By finding the "most economical" connection path, it prioritizes the execution of connection operations that generate the smallest intermediate results, effectively preventing an explosive growth of intermediate results in the early stages of assembly, thereby smoothing out the overall computational overhead.

[0077] S35: After determining the optimal merge target, parse the substructure. and The type origin, if the substructure belongs to the star-shaped unit of the initial decomposition, is determined from the pre-calculated star-shaped matching result vector. The corresponding ciphertext table is indexed and read. If it belongs to the intermediate result generated in the previous round, the temporary ciphertext table in memory is read directly.

[0078] Specifically, because the assembly process mixes the original star schema and intermediate results, the system needs to dynamically locate the data source. For the basic star schema, from the vector... Data is extracted from the memory; for complex substructures that have already been merged, data is read directly from a temporary container in memory.

[0079] S36: Using a multi-party secure connection protocol, perform a join operation on the two read ciphertext tables to generate a new merged substructure. The corresponding ciphertext matching results are then recorded and marked as a temporary ciphertext table.

[0080] Specifically, the selected two substructures implement the actual secure connection between the multi-party servers. This step concatenates the two local matching tables based on common vertices, generating a new substructure that is larger and covers a wider topology. .

[0081] S37: Update assembly state from set Remove substructures that have already participated in the connection. and The newly generated merged substructure Add to collection Reset the least connection cost Then return to step S32 to begin the next iteration.

[0082] Specifically, with the two substructures and Merge into one structure ,gather The size is reduced by 1; the system updates the set state to reflect the latest topology and resets the cost. This prepares for the next round of searching for new optimal merge pairs, until all substructures have been merged.

[0083] S38: When set When only one substructure remains, initiate the symmetry verification process and read the symmetry vertex grouping information pre-calculated based on the automorphism properties of the query graph. .

[0084] Specifically, after entering the verification phase, the system loads pre-calculated auxiliary information. This information identifies all topologically equivalent vertex groups in the query graph, such as any node in a fully connected graph or a rotating node in a ring structure. These symmetries are the root cause of redundant results.

[0085] S39: Ciphertext table corresponding to this unique substructure Each ciphertext tuple in Based on the symmetric vertex grouping information, the attribute values ​​in the tuple are divided into several corresponding attribute sub-vectors.

[0086] Specifically, the system parses the encrypted result table and extracts the vertex IDs belonging to the same symmetric group for each record. For example, if the query graph contains a triangle... If these three points are symmetrical, the system will extract the ciphertext values ​​at these three positions to form a sub-vector, which will then be used for consistency checks.

[0087] S310: Construct a multi-party secure comparison module that, for each attribute subvector, verifies in ciphertext whether its internal elements strictly follow a predefined monotonic partial order relationship (such as ascending order) to break symmetry.

[0088] Specifically, this is key to eliminating redundancy. The system constructs a comparison circuit in MPC to check whether the ID values ​​corresponding to the symmetrical vertices satisfy a specific order, such as... Since symmetric matching is merely a permutation of node order, it enforces a specific permutation order that can uniquely preserve a typical instance, thereby logically eliminating all other duplicate permutations.

[0089] S311: Aggregate the verification results. If any attribute subvector violates the partial order relation, an invalid flag is generated, and the validity bit (isNull) of the tuple is updated by a logical OR operation.

[0090] Specifically, a tuple is considered redundant if it violates the order constraint in any symmetric set. The system uses a Boolean circuit to update the isNull flag of that row, logically setting it to "invalid" without revealing which row was marked.

[0091] S312: Perform logical filtering on the final result table based on the validity bit, remove all redundant tuples marked as invalid, and output accurate non-redundant subgraph matching results.

[0092] Specifically, the system cleans the result table by performing unintentional compression or direct filtering based on the isNull bit, removing all redundant rows, and delivering to the user a final matching result set that is both accurate (satisfying the definition of graph isomorphism) and compact (without repeated permutations).

[0093] like Figure 4 As shown, the star schema assembly process gradually merges the star schema matching results obtained in the previous step into the matching results of the complete query graph: the server first reads the star schema matching results of size 2. Matching results with a star-shaped graph of size 3 and through encrypted connection operation Combine the two to generate an intermediate matching result. The server then continued to... Matching results with the remaining star schema Perform a join to obtain the matching results corresponding to the complete query graph. Finally, the server... Execute the symmetry verification protocol to eliminate redundant matches caused by the automorphism of the query graph, and output the final subgraph matching results without redundancy.

[0094] The above description of the embodiments is provided to enable those skilled in the art to understand and apply the present invention. Those skilled in the art can readily make various modifications to the above embodiments and apply the general principles described herein to other embodiments without creative effort. Therefore, the present invention is not limited to the above embodiments, and any improvements and modifications made to the present invention by those skilled in the art based on the disclosure thereof should be within the scope of protection of the present invention.

Claims

1. A multi-party secure subgraph matching method based on star decomposition and topology reuse, characterized in that, Includes the following steps: (1) The query graph topology is parsed using the star decomposition strategy. Through greedy coverage and load balancing optimization, the complex query graph is transformed into a set of star substructures with the maximum star size minimized. (2) The computation is performed using a multi-party secure connection protocol and a topology reuse mechanism is introduced. The largest star substructure in the set is selected as the computation object, and its intermediate matching result is used to directly cover the isomorphic small star substructure in the set. (3) Assemble the matching results of each star substructure based on a greedy strategy, and use a symmetry verification protocol to remove redundant tuples to generate the final matching result.

2. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 1, characterized in that, The specific implementation method of step (1) is as follows: A1. With the goal of quickly covering all query edges, the vertex with the largest current degree is repeatedly selected as the center in the subgraph formed by the remaining edges, and the star substructure containing all its associated edges is extracted to form the initial set of star substructures. A2. With the goal of minimizing the maximum star shape size, iterative edge migration is performed on the initial set of star substructures, migrating the corresponding edges from the maximum star substructure to the smaller star substructure, thereby reducing the size of the maximum star substructure.

3. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 2, characterized in that, The specific implementation process of step A1 is as follows: S11: Initialize the decomposition state and construct an empty set of star-shaped substructures. SQ And assign the original edge set of the query graph to the remaining edge set. , as the initial set of edges to be covered; S12: In the case of The degree of each vertex in the resulting subgraph is recalculated, and the vertex with the highest degree is selected as the center node. u ; S13: Building with u It is the root and contains it in Add the star substructure of all associated edges to the star substructure. SQ In, and from these associated edges Remove from; S14: Detection If the value is not empty, return to step S12 to continue decomposition; otherwise, proceed to the balancing stage.

4. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 3, characterized in that, The specific implementation process of step A2 is as follows: S15: Initiate the iterative balancing optimization process, initialize the optimization state flag to false, and scan the current set. SQ Identify the largest star-shaped substructure containing the most edges. q max And record its center node as u r ; S16: Traversal Search q max leaf nodes in v And the leaf node v for SQ Another star-shaped substructure q v The central node; S17: For node pairs that meet the conditions ( u r , v Perform load difference detection and determine... q max Size and q v If the size difference is greater than a preset threshold, then proceed to step S18. S18: Transfer node pairs ( u r , v The edge of ) from q max Migrate to q v Set the optimization status flag to true and stop the current traversal; S19: Check the current optimization state flag. If it is true, return to step S15 and iterate again. If it is false, output the final star-shaped substructure set. SQ .

5. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 1, characterized in that, The specific implementation method of step (2) is as follows: B1. First, identify the largest star substructure and its central node, and initialize the star matching result vector and intermediate result container; then, use the multi-party secure sorting protocol to sort the ciphertext edge matching table globally with the central node as the sorting key, so that it is arranged in a logically ordered manner according to the predefined interval and start the iterative incremental matching process. B2. Based on the number of edges already processed i For indexing, iterate over each edge of the largest star substructure: in each round, first construct a semantically consistent right operand table by renaming attributes, then perform bucketed parallel encrypted joins based on the interval characteristics of the ordered table, and finally aggregate to generate the current size. i Partial matching of intermediate results; then immediately scan the set to see if there are any items of the same size. i If a small star-shaped substructure exists, the intermediate result is directly assigned to the corresponding result vector, saving the need for independent connection calculations.

6. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 5, characterized in that, The specific implementation process of step B1 is as follows: S21: Initialize the matching environment in the star-shaped substructure set. SQ The largest star-shaped substructure was identified in the middle. q max and its central node u r And initialize the vector used to store the star-shaped matching results of each size. ; S22: Perform data rearrangement using a multi-party secure ordering protocol. u r The encrypted edge matching table is sorted using the sort key, so that its tuples are arranged in an ordered manner in physical storage according to the predefined interval partitioning logic, forming an ordered table; S23: Initialize the intermediate result container and target... q max For each edge in the process, an iterative incremental matching process is initiated, and the number of edges processed in the current iteration is recorded as follows: i .

7. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 6, characterized in that, The specific implementation process of step B2 is as follows: S24: In each iteration, perform attribute renaming operations on the ordered table according to the currently processed edges to construct a right operand table that is semantically consistent with the current connection pattern; S25: Utilize the bucket join algorithm in the multi-party secure connection protocol to... u r Using the common join key, the data is divided into multiple independent logical buckets by leveraging the range characteristics of the ordered table, and the encrypted join within the buckets is performed in parallel between the intermediate result container and the right operand table. S26: Aggregate the connection outputs of each logic bucket, update the intermediate result container, where the intermediate result represents the current size of... i The star topology matches all partial instances in the original graph data; S27: Perform topology reuse detection, scanning the set of star-shaped substructures. SQ Determine if there exists a size equal to i If it is a small star-shaped substructure, then proceed to step S28; S28: Perform a result overwrite operation, directly assigning the current intermediate result to the vector. The corresponding elements are used to skip the independent connection calculations for these small star-shaped substructures; S29: Repeat steps S24 to S28 until... q max After all edges have been processed, the output contains a set. SQ The vector of matching results for all star-shaped substructures in the vector .

8. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 7, characterized in that, The specific implementation method of step (3) is as follows: C1. Treat the star-shaped substructure set as the unit to be merged, start a greedy iterative loop, traverse all possible substructure pairs in each round, use the cost estimation function to predict the size of the merged result, select the pair with the smallest estimated value as the best merge object; then read the corresponding ciphertext table from the result vector or temporary table, perform a multi-party secure connection to generate a new merged substructure, and replace it back into the set, repeat this process until only one global substructure and its matching ciphertext table remain in the set; C2. After obtaining the unique global matching ciphertext table, start the symmetry verification process: read the symmetric vertex grouping information generated in advance based on the automorphism of the query graph, and divide the attribute values ​​of each ciphertext tuple into sub-vectors according to the group; Using a multi-party secure comparison module, the system verifies whether the elements in each sub-vector of the tuple satisfy a predefined partial order relation. If not, the entire tuple is marked as invalid. Finally, the ciphertext table is filtered based on the validity bit to remove all redundant tuples caused by symmetry.

9. The multi-party secure subgraph matching method based on star decomposition and topology reuse according to claim 8, characterized in that, The specific implementation process of step C2 is as follows: S38: When set SQ When only one substructure remains, the symmetry verification process is initiated, and the symmetry vertex grouping information pre-calculated based on the automorphism property of the query graph is read. S39: Ciphertext table corresponding to this unique substructure Each ciphertext tuple in the tuple is divided into several corresponding attribute sub-vectors based on the symmetric vertex grouping information. S310: Construct a multi-party secure comparison module to verify, in ciphertext state, whether the internal elements of each attribute subvector strictly follow a predefined monotonic partial order relationship in order to break the symmetry; S311: Aggregate the verification results. If any attribute sub-vector violates the partial order relation, an invalid flag is generated, and the validity bit of the ciphertext tuple is updated by a logical OR operation. S312: Pair the ciphertext table with validity bits Perform logical filtering to remove all redundant tuples marked as invalid, and output accurate, non-redundant subgraph matching results.

Images