Methods for protecting membership in secure multiparty computing and / or communications, secure multiparty computing and communications systems, non-temporary computer-readable media, and computer programs

Abstract

Membership protection in secure multi-party computing and communications is provided. A method for protecting membership includes generating a padding dataset, upsampling a first dataset using the padding dataset, transforming and dispatching the first dataset, receiving a second dataset, and generating a third dataset by performing secure set intersection operations on the first and second datasets. Each of the first dataset, the padding dataset, and / or the second dataset contains one or more personally identifiable pieces of information about each user or member in the dataset.

Description

Technical Field

[0001] (Reference to Related Applications) This application claims priority to U.S. Application No. 18 / 297,530, filed on April 7, 2023 (inventive title: Protection of Membership in Confidential Multi-Party Computation and / or Communication), the disclosure of which is incorporated herein by reference in its entirety.

[0002] (Technical Field) The embodiments described herein generally relate to protecting membership privacy. More specifically, the embodiments described herein relate to protecting membership privacy (such as elements, members, users, etc.) in confidential multi-party computation and / or communication.

Background Art

[0003] Private set intersection (PSI) is one of the secure two-party or multi-party protocols or algorithms where common subset-related statistics are computed, and PSI has received significant interest from the industry. With a PSI algorithm or protocol, two or more organizations are allowed to jointly compute a function (such as count, sum, etc.) on the common subset of their respective datasets without explicitly exposing the common subset to other parties. In applications, two parties may not want or may not be able to expose their underlying data to each other, but still may want to compute an aggregate-level measurement. These two parties may want to do so while ensuring that the input datasets do not expose anything beyond these aggregate values related to individual users.

Summary of the Invention

Problems to be Solved by the Invention

[0004] Features of embodiments disclosed herein may provide a PSI algorithm or protocol that keeps users in a dataset anonymous during a PSI operation, for example, based on a differential privacy (DP) protocol or algorithm. Features of embodiments disclosed herein can help prevent potential membership leaks or exposures during a PSI operation by integrating the protocol or algorithm with a DP protocol or algorithm for datasets or common parts of datasets that have one or more Personal Identification Information (PII) for each user or member in a record or row of a common part of a dataset or dataset.

[0005] A feature of the embodiments disclosed herein is that padding or filler elements may be generated independently for each party's dataset according to a pre-calibrated noise distribution, the padding elements may be added to each dataset, and a PSI algorithm or protocol may be executed. Another feature of the embodiments disclosed herein is that the common size exposed in subsequent PSI operations is random and differentially concealed, making it virtually impossible for an attacker to determine a user's dataset or membership in an organization, and enabling compliance with the requirements of personal data protection regulations. [Means for solving the problem]

[0006] In one exemplary embodiment, a method is provided for protecting membership in confidential multi-party computing and communications. The method includes providing a first dataset containing a first identity field and a second identity field, and generating a padding dataset. The size of the padding dataset is determined based on data privacy settings. The method also includes upsampling a first dataset using a padding dataset, transforming and dispatching the first dataset, receiving a second dataset having a third and a fourth identification field, and generating a third dataset by performing an intersection operation on the first and second datasets, by removing the row containing the matching identification from the second dataset and adding the removed row to the third dataset for each identification in the first identification field that matches an identification in the third identification field, and removing the row containing the matching identification from the second dataset and adding the removed row to the third dataset for each identification in the second identification field that matches an identification in the fourth identification field.

[0007] In another exemplary embodiment, a secure multiparty computing and communication system is provided. The system comprises a memory for storing a first dataset, and a processor that provides a first dataset including a first identity field and a second identity field, and generates a padding dataset. The size of the padding dataset is determined based on data privacy settings. The processor further upsamples the first dataset using the padding dataset, transforms and dispatches the first dataset, receives a second dataset having a third identity field and a fourth identity field, and generates a third dataset by performing an intersection operation on the first dataset and the second dataset, by removing the row containing the matching identity from the second dataset and adding the removed row to the third dataset for each identity in the first identity field that matches an identity in the third identity field, and removing the row containing the matching identity from the second dataset and adding the removed row to the third dataset for each identity in the second identity field that matches an identity in the fourth identity field.

[0008] In yet another embodiment, a non-temporary computer-readable medium storing computer-executable instructions is provided. When an instruction is executed, one or more processors are caused to perform operations including providing a first dataset containing a first identification information field and a second identification information field, and generating a padding dataset. The size of the padding dataset is determined based on data privacy settings. The operation also includes generating a third dataset by performing an intersection operation on the first and second datasets, by upsampling the first dataset using a padding dataset, transforming and dispatching the first dataset, receiving a second dataset having a third and a fourth identification field, deleting the row containing the matched identification from the second dataset and adding the deleted row to the third dataset for each identification in the first identification field that matches an identification in the third identification field, and deleting the row containing the matched identification from the second dataset and adding the deleted row to the third dataset for each identification in the second identification field that matches an identification in the fourth identification field. [Brief explanation of the drawing]

[0009] The accompanying drawings illustrate various embodiments of the systems and methods of the Disclosure, and embodiments of various other aspects of the Disclosure. Those skilled in the art will understand that the illustrated element boundaries in the drawings (e.g., boxes, groups of boxes, or other shapes) represent examples of boundaries. In some examples, one element may be designed as multiple elements, or multiple elements may be designed as one element. In some examples, an element shown as an internal component of one element may be realized as an external component of another element, and vice versa. The following description is non-limiting and non-exclusive, with reference to the drawings. The components in the drawings are not necessarily to scale, and the emphasis is on illustrating the principle. Since various changes and modifications may become apparent to those skilled in the art from the following detailed description, embodiments are described only as illustrations in the following detailed description.

[0010] [Figure 1] This is a schematic diagram showing an exemplary secure computation and communication system arranged according to at least some embodiments described herein.

[0011] [Figure 2] This flowchart shows an exemplary processing flow for a multi-identification matching algorithm according to at least some embodiments described herein.

[0012] [Figure 3] This is a schematic diagram showing an example of the processing flow in Figure 2, according to at least some embodiments described herein.

[0013] [Figure 4A] This flowchart shows an exemplary processing flow for protecting membership privacy in confidential multi-party computing and communications, according to at least some embodiments described herein. [Figure 4B]A flowchart showing an exemplary processing flow for protecting membership privacy in secret multi-party computing and communication according to at least some embodiments described herein.

[0014] [Figure 5A] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein. [Figure 5B] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein. [Figure 5C] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein. [Figure 5D] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein. [Figure 5E] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein. [Figure 5F] A diagram showing a portion of a schematic diagram illustrating an example of the processing flows of FIGS. 4A and 4B according to at least some embodiments described herein.

[0015] [Figure 6] A schematic configuration diagram of an exemplary computer system applicable to realizing an electronic device arranged according to at least some embodiments described herein.

MODE FOR CARRYING OUT THE INVENTION

[0016] In the following detailed description, specific embodiments of the present disclosure will be described with reference to the accompanying drawings that form a part of the specification. In this specification and the drawings, similar reference numerals represent elements that can perform the same, similar, or equivalent functions, unless the context indicates otherwise. Further, unless otherwise specified, the description of each successive drawing may refer to the features of the previous one or more drawings to provide a clearer context and a more substantial description of the current exemplary embodiment. However, the embodiments described in the detailed description, the drawings, and the claims are not intended to be limiting. Other embodiments may be utilized and other changes may be made without departing from the spirit or scope of the subject matter presented herein. As is readily understood, each aspect of the present disclosure may be designed in various different configurations, such as arrangement, replacement, combination, separation, which are all clearly contemplated herein.

[0017] It should be understood that the disclosed embodiments are merely examples that can be embodied in various forms of the present disclosure. To avoid obscuring the present disclosure with unnecessary details, well-known functions or structures will not be described in detail. Therefore, the specific structural details and functional details described herein should be construed not as limitations but merely as a basis for the claims and as a representative basis for teaching those skilled in the art to utilize the present disclosure in a wide variety of substantially appropriate detailed structures.

[0018] Additionally, the present disclosure may be described with respect to functional block components and various processing steps. It should be understood that such functional blocks may be implemented by any number of hardware and / or software components configured to perform the specified functions.

[0019] The scope of this disclosure should be determined by the appended claims and their legal equivalents, rather than by the examples given herein. For example, the steps described in any method claim may be performed in any order, and are not limited to the order described in the claim. Furthermore, unless specifically stated herein as “material” or “essential,” there are no elements essential to the practice of this disclosure.

[0020] As described herein, “data set” or “dataset” is a technical term and may refer to an organized collection of data that is stored and accessed electronically. In exemplary embodiments, a dataset may refer to a database, a data table, a part of a database or data table, etc. A dataset may correspond to one or more dataset tables, where each column represents a specific variable or field and each row corresponds to a given record in the dataset. The dataset may enumerate the values ​​of each of the variables and / or each record in the dataset. It should also be understood that, as an addition or alternative, a dataset may refer to a set of related data and the way in which such related data is organized. In exemplary embodiments, each record in a dataset may include a field or element, for example, one or more predefined or predetermined identifying information (e.g., membership identifying information, user identifying information, e.g., username, email address, telephone number, unique ID of the user), and / or one or more attributes, features, or values ​​associated with such one or more identifying information. Any user identification information and / or user data described herein should be understood to be authorized, authorized and / or otherwise approved by the user for use in the embodiments described herein and their appropriate legal equivalents as understood by those skilled in the art.

[0021] In this specification, “inner join” or “inner-join” is a technical term and may refer in particular to an operation or function that involves combining records from datasets when there are matching values ​​in a common field of the datasets. For example, an inner join may be performed on the “Departments” dataset and the “Employees” dataset to determine all employees in each department. It should be understood that in the resulting dataset of an inner join operation (i.e., the “common part”), the inner join may include information from both datasets that are related to each other. An outer join, on the other hand, may also include information in the resulting dataset that is not related to the other dataset. A confidential inner join may refer to an inner join operation of two or more parties' datasets that does not expose data in the common part of the datasets of the two or more parties.

[0022] As used herein, “hashing” may refer to an operation or function that transforms or converts an input (a key, e.g., a number, a string, etc.) into an output (e.g., another number, another string, etc.). It should be understood that hashing is a technical term and may be used in cybersecurity applications to access data in a short and nearly constant time for each lookup.

[0023] As used herein, “MPC” or “multi-party computation” is a technical term that may also refer to the field of cryptography aimed at creating a scheme for parties to jointly compute a function on a shared input while keeping each party’s input confidential. Unlike traditional cryptographic tasks where cryptography can guarantee the security and integrity of communications or storage when adversaries are outside the participants’ systems (e.g., eavesdroppers on the sender and / or receiver), it should be understood that cryptography in MPC can protect the privacy of the participants from one another.

[0024] As used herein, “ECC” or “elliptic-curve cryptography” is a technical term and may refer to public-key cryptography based on the algebraic structure of elliptic curves over a finite field. It should be understood that ECC can tolerate smaller keys compared to non-EC cryptography in order to provide equal security. It should also be understood that “EC” or “elliptic curve” can be applied to key agreement, digital signatures, pseudorandom number generators, and / or other tasks. Elliptic curves can be used indirectly in encryption by combining key agreement between parties with symmetric encryption schemes. Elliptic curves can also be used in integer factorization algorithms based on elliptic curves that are applied to encryption.

[0025] As used herein, the “Deterministic Diffie-Hellman Assumption” or “DDH Assumption” is a technical term and may refer to a computational complexity assumption concerning a particular problem involving discrete logarithms in cyclic groups. It should be understood that the DDH assumption may be used as the basis for proving the security of many cryptographic protocols.

[0026] As used herein, “Elliptic Curve Diffie-Hellman” or “ECDH” is a technical term that may refer to a key agreement protocol or corresponding algorithm that enables two or more parties, each possessing an elliptic curve public-private key pair, to establish a shared secret over a non-secret channel. It should be understood that the shared secret can be used directly as a key or to derive another key. It should also be understood that the key, or a derived key, may be used to encrypt or encode subsequent communications using symmetric key ciphertext. Furthermore, it should be understood that ECDH may refer to a variation of the Diffie-Hellman protocol using elliptic curve cryptography.

[0027] As used herein, “secret set intersection operation” is a technical term and may refer to a secure multi-party computational cryptographic operation, algorithm, or function in which two or more parties, each holding a dataset, compare encrypted versions of these datasets in order to compute a common part. It should be understood that with a secret set intersection operation, neither party exposes to the other any data elements other than those in the common part.

[0028] As used herein, “shuffle,” “shuffling,” “rearrange,” or “sort” are technical terms and may refer to an operation or algorithm for rearranging and / or randomly rearranging the order of records (elements, rows, etc.) in, for example, arrays, datasets, databases, data tables, etc.

[0029] As used herein, “Differential Privacy” or “DP” is a technical term and may refer to standards, protocols, systems, and / or algorithms for publicly sharing information about a dataset by describing patterns of groups of elements within the dataset while concealing information about individual users enumerated in the dataset. It should be understood that differential privacy may also refer to constraints on algorithms used to release aggregated information about a statistical dataset or database to users that limit the disclosure of personal information of individual records in the dataset or database.

[0030] The following are non-exclusive examples of the background, setting, or application of differential privacy. A trusted data owner (or data holder or curator, e.g., a social media platform, website, service provider, application, etc.) may store a dataset of sensitive information about a user or member (e.g., the dataset contains records / rows of a user or member). Each time the dataset is queried (or manipulated, e.g., analyzed, processed, used, stored, shared, accessed, etc.), there may be a possibility or probability of an individual's privacy being compromised (e.g., a probability of data privacy breach or privacy loss). Differential privacy can provide a rigorous framework and security definition for algorithms that manipulate sensitive data and expose aggregate statistics in order to prevent an individual's privacy from being compromised, for example, by resisting link attacks or auxiliary information and / or by providing limits on the quantitative measure of harm (privacy breach, privacy loss, etc.) caused by individual records in a dataset.

[0031] It should be understood that the above requirements for a differential privacy protocol or algorithm may refer to a measure of "how much data privacy is granted when performing an operation or function (e.g., by a single query or operation on an input dataset)." The DP parameter "ε" may refer to the privacy budget (i.e., the limit on the amount of data privacy that is permissible in leakage), which represents, for example, the maximum difference between a query or operation on dataset A and the same query or operation on dataset A' (which differs from A by only one element or record). A smaller value of ε indicates stronger privacy protection for the multi-identity privacy protection mechanism. Another DP parameter "δ" may refer to a probability, such as the probability of information being leaked by chance. In an exemplary embodiment, the required or predetermined range of ε may be from about 1 to about 3. The required or predetermined range of δ may be from about 10⁻¹⁰ (or about 10⁻⁸) to about 10⁻⁶. Yet another DP parameter, sensitivity, may refer to a quantified amount of how much noise perturbation is required in the DP protocol or algorithm. It should be understood that determining sensitivity may require determining the maximum possible change in the results. In other words, sensitivity may refer to the potential impact that changes in the underlying dataset may have on the results of queries to that dataset.

[0032] As used herein, “differential privacy synthesis” or “DP synthesis” is a technical term and may refer to the total or overall differential privacy when a particular dataset is queried (or operated on, e.g., analyzed, processed, used, stored, shared, accessed, etc.) two or more times. DP synthesis quantifies the overall differential privacy (which may be reduced by considering the DP of a single query or operation) when multiple separate queries or operations are performed on a single dataset. It should be understood that if a single query or operation on a dataset has a privacy loss L, the cumulative effect of N queries on data privacy (referred to as N-fold synthesis or N-fold DP synthesis) may be greater than L and less than L*N. In one exemplary embodiment, N-fold DP synthesis may be determined based on an N-fold convolution operation of the privacy loss distributions. For example, DP synthesis of two queries may be determined based on the convolution of the privacy loss distributions of the two queries. In one exemplary embodiment, the number N may be about 10, about 25, or any other suitable number. In exemplary embodiments, ε, δ, sensitivity, and / or number N may be predetermined to achieve a desired or predetermined data privacy protection objective or performance.

[0033] Figure 1 is a schematic diagram showing an exemplary secure computation and communication system 100 arranged according to at least some embodiments described herein.

[0034] System 100 may include terminal devices 110, 120, 130, and 140, a network 160, and a server 150. It should be understood that Figure 1 shows only an exemplary number of terminal devices, networks, and servers. The embodiments described herein are not limited to the number of terminal devices, networks, and / or servers described herein. That is, the number of terminal devices, networks, and / or servers described herein is provided for illustrative purposes only and is not intended to limit the number of terminal devices, networks, and / or servers described herein.

[0035] According to at least some embodiments, terminal devices 110, 120, 130, and 140 may be various electronic devices. These various electronic devices may include, but are not limited to, mobile devices such as smartphones, tablet computers, e-readers, laptop computers, desktop computers, and / or any other suitable electronic devices.

[0036] According to at least some exemplary embodiments, the network 160 may be a medium used to provide communication links between terminal devices 110, 120, 130, 140 and the server 150. The network 160 may be the internet, a local area network (LAN), a wide area network (WAN), a local interconnect network (LIN), a cloud, etc. The network 160 may be implemented by various types of connections such as wired communication links, wireless communication links, fiber optic cables, etc.

[0037] According to at least some embodiments, the server 150 may be a server that provides various services to users using one or more of the terminal devices 110, 120, 130, and 140. The server 150 may be implemented as a distributed server cluster including multiple instances of the server 150, or as a single server 150.

[0038] Users may interact with the server 150 via the network 160 using one or more of the terminal devices 110, 120, 130, and 140. Various applications or localized interfaces, such as social media applications and online shopping services, may be installed on the terminal devices 110, 120, 130, and 140.

[0039] Software applications or services relating to embodiments described herein, or services provided by a service provider, may be executed by server 150 and / or terminal devices 110, 120, 130, and 140 (which may be referred to herein as user devices). Accordingly, the equipment for the software applications and / or services may be located within server 150 and / or terminal devices 110, 120, 130, and 140.

[0040] Furthermore, it should be understood that if the service is not running remotely, system 100 may include only terminal devices 110, 120, 130, and 140 and / or server 150, without including network 160.

[0041] Furthermore, it should be understood that each of the terminal devices 110, 120, 130, and 140 and / or server 150 may also include one or more processors, memory, and a storage device for storing one or more programs. Each of the terminal devices 110, 120, 130, and 140 and / or server 150 may also include, respectively, an Ethernet connector, a wireless fidelity receptor, and the like. When the one or more programs are executed by the one or more processors, they may cause the one or more processors to perform the methods described in any embodiment described herein. It should also be understood that a computer-readable non-volatile medium may be provided according to the embodiments described herein. The computer-readable medium stores computer programs. When the computer programs are executed by the processors, they are used to perform the methods described in any embodiment described herein.

[0042] Figure 2 is a flowchart illustrating an exemplary processing flow 200 for a multi-identity matching algorithm according to at least some embodiments described herein.

[0043] Figure 3 is a schematic diagram showing an example of the processing flow 300 of Figure 2 according to at least some embodiments described herein. Therefore, the description of the processing flow 200 may refer to 310A, 310B, 320A, and 320B of schematic diagram 300.

[0044] It should be understood that the processing flow 200 disclosed herein may be performed by one or more processors (for example, the processors of one or more terminal devices among the terminal devices 110, 120, 130, and 140 in Figure 1, the processor of the server 150 in Figure 1, the central processor unit 605 in Figure 6, and / or any other suitable processor) unless otherwise specified.

[0045] It should also be understood that the processing flow 200 may include one or more operations, behaviors, or functions, as indicated by one or more of blocks 210, 220, 230, and 240. These various operations, behaviors, or actions may correspond, for example, to processor-executable software, program code, or program instructions that cause these functions to be performed. Although shown as discrete blocks, obvious modifications may be made, for example, by rearranging two or more of the blocks, by adding more blocks, and by splitting various blocks into additional blocks, combining them into fewer blocks, or removing them, as desired. The processing flow 200 may begin in block 210.

[0046] In block 210 (initialization), the processor of each device may perform initialization functions or operations on, for example, system parameters and / or application parameters. The processor of each device may provide a dataset (e.g., 310A) for party 1 and / or provide a dataset (e.g., 310B) for party 2. It should be understood that datasets 310A and / or 310B may be upsampled datasets (e.g., 508A and / or 508B in Figure 5A) generated or acquired in block 420 of Figure 4A, as will be described in more detail below.

[0047] Furthermore, it should be understood that each dataset 310A or 310B may contain one or more identification (ID) fields or columns, and the number of identification fields or columns in dataset 310A may or may not be equal to the number of identification fields or columns in dataset 310B. As shown in Figure 3, each of datasets 310A and 310B contains two ID fields, id1 and id2.

[0048] In one exemplary embodiment, the processor of each device may shuffle dataset 310A for party 1 and / or shuffle dataset 310B for party 2. The processor may also transform the ID field of dataset 310A using a transformation scheme for party 1.

[0049] It should be understood that a function or operation for "transforming" or "transforming" one or more fields / columns (or records / rows) of a dataset or a portion thereof, such as one or more ID fields / columns (or records / rows), may also mean processing (e.g., encrypting, decrypting, coding, decrypting, manipulating, compressing, decompressing, converting, etc.) the dataset or a portion thereof. A "transformation method" may also mean an algorithm, protocol, or function that performs processing (e.g., encrypting, decrypting, coding, decrypting, manipulating, compressing, decompressing, converting, etc.) of the dataset or a portion thereof. In one embodiment, the processor may encrypt (or decrypt, code, decrypt, manipulate, compress, decompress, convert, etc.) the ID field of dataset 310A using, for example, the key of party 1, based on, for example, the ECDH algorithm or protocol.

[0050] The processor may also transform the ID field of dataset 310B using a transformation scheme for party 2. In one embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) the ID field of dataset 310B using, for example, the key of party 2, based on, for example, the ECDH algorithm or protocol.

[0051] For Party 1 and / or Party 2, the order in which the ID field of the dataset (310A or 310B) is transformed and the shuffling of the dataset (310A or 310B) may be switched or changed without affecting the purpose of the resulting dataset.

[0052] The processor of each device may further exchange dataset 310A and dataset 310B between party 1 and party 2. For party 1, the processor may dispatch or transmit dataset 310A to party 2 and receive or acquire dataset 310B from party 2. For party 2, the processor may dispatch or transmit dataset 310B to party 1 and receive or acquire dataset 310A from party 1. It should be understood that since datasets 310A and 310B have already been transformed (e.g., encoded), the corresponding receiving party may not know the actual data in the received dataset. It should now be understood that each party may have local copies of both dataset 310A and dataset 310B.

[0053] The processor of each device may further transform the ID field of the received transformed dataset 310B using a transformation scheme for Party 1. In one embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, convert, etc.) the ID field of the received transformed dataset 310 using the key of Party 1, for example, based on the ECDH algorithm or protocol. The processor of each device may further transform the ID field of the received transformed dataset 310A using a transformation scheme for Party 2. In one embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, convert, etc.) the ID field of the received transformed dataset 310A using the key of Party 2, for example, based on the ECDH algorithm or protocol.

[0054] The processor may also shuffle the received converted dataset 310A for party 2 and / or the received converted dataset 310B for party 1. The order of the conversion of the ID field of the received converted datasets (310A and / or 310B) and the shuffling of the received converted datasets (310A and / or 310B) for party 1 and / or party 2 may be switched or changed without affecting the purpose of the resulting dataset. The processor of each device may exchange the resulting shuffled dataset 310A (referred to as "310A" in blocks 220-240 for simplicity of explanation) and the resulting shuffled dataset 310B (referred to as "310B" in blocks 220-240 for simplicity of explanation) between party 2 and party 1. Processing may proceed from block 210 to block 220.

[0055] In block 220 (Sorting Datasets), the processor of each device may sort datasets 310A and / or dataset 310B for party 1 and / or party 2. For example, for party 1, the processor may sort the ID fields (id1, id2, etc.) of dataset 310A in an order (or sequence) corresponding to a predetermined importance or priority level of the ID fields. Dataset 310A may include ID fields such as username (e.g., having a priority level of 3), email address (e.g., having a priority level of 2), telephone number (e.g., having a priority level of 4), unique user ID (e.g., having a priority level of 1), etc. In one exemplary embodiment, the lower the priority level number, the more important the corresponding ID field. By sorting the ID field in dataset 310A, the user's unique ID (e.g., with a priority level of 1) is listed as the first field / column in dataset 310A, the email address (e.g., with a priority level of 2) is listed as the second field / column in dataset 310A, the username (e.g., with a priority level of 3) is listed as the third field / column in dataset 310A, and the phone number (e.g., with a priority level of 4) is listed as the fourth field / column in dataset 310A. In other words, in a non-restrictive example of dataset 310A, the ID field is sorted in ascending order of priority level numbers for the user's unique ID, email address, username, and user phone number.

[0056] For party 2, the processor may sort the ID fields (id1, id2, etc.) of dataset 310B in the same order (or sequence) as for dataset 310A for party 1, corresponding to a predetermined importance or priority level of the ID fields. It should be understood that the sorting of datasets 310A and 310B is for the purpose of preparing for the subsequent matching process. Processing may proceed from block 220 to block 230.

[0057] In block 230 (execution of matching logic), with datasets 310A and 310B sorted, the processor of each device may search for a match (or an inner join operation, etc.) between dataset 310A and dataset 310B for each ID field of dataset 310A (from the ID field with the lowest priority level number to the ID field with the highest priority level number), and obtain or generate a common part for party 1 (dataset 320A in Figure 3).

[0058] It should be understood that the search for a matching operation (or an inner join operation, etc.) involves, for each ID field in dataset 310A (from the ID field with the lowest priority level number to the ID field with the highest priority level number), and for each identifier in dataset 310A that matches an identifier in dataset 310B, deleting the record (or row) in dataset 310A that contains the matched identifier, and adding or appending the deleted record (or row) from dataset 310A to dataset 320A.

[0059] For example, as shown in Figure 3, for the ID field id1 in dataset 310A, records / rows containing "g", "c", and "e" each have corresponding matches in dataset 310B. Such records / rows may be deleted from dataset 310A, and the deleted records / rows may be added or appended to dataset 320A. For the ID2 in dataset 310A, records / rows containing "3" have corresponding matches in dataset 310B. Such records / rows may be deleted from dataset 310A, and the deleted records / rows may be added or appended to dataset 320A.

[0060] The processor of each device may search for a match (or perform an inner join operation, etc.) between dataset 310A and dataset 310B for each ID field of dataset 310B (from the ID field with the lowest priority level number to the ID field with the highest priority level number) and obtain or generate a common part for party 2 (dataset 320B in Figure 3).

[0061] It should be understood that the search for a matching operation (or an inner join operation, etc.) involves, for each ID field in dataset 310B (from the ID field with the lowest priority level number to the ID field with the highest priority level number), and for each identifier in dataset 310B that matches an identifier in dataset 310A, deleting the record (or row) in dataset 310B that contains the matched identifier, and adding or appending the deleted record (or row) from dataset 310B to dataset 255B.

[0062] For example, as shown in Figure 3, for the ID field id1 in dataset 310B, records / rows containing "g", "c", and "e" each have corresponding matches in dataset 310A. Such records / rows may be deleted from dataset 310B, and the deleted records / rows may be added or appended to dataset 320B. For the ID2 in dataset 310B, records / rows containing "3" have corresponding matches in dataset 310A. Such records / rows may be deleted from dataset 310B, and the deleted records / rows may be added or appended to dataset 320B.

[0063] It should be understood that the matching logic / algorithm calculation may be performed until all ID fields in dataset 310A have been processed for party 1 and / or until all ID fields in dataset 310B have been processed for party 2. Processing may proceed from block 230 to block 240.

[0064] In block 240 (common part generation), if all ID fields of dataset 310A have been processed, the processor of each device may generate a common part / dataset 320A for party 1. If all ID fields of dataset 310B have been processed, the processor of each device may generate a common part / dataset 320B for party 2.

[0065] It should be understood that the common parts 320A and / or 320B may be used for other MPC processing, such as generating secret shares based on common parts 320A and / or 320B, collecting secret shares, and / or generating results by combining collected secret shares.

[0066] Figures 4A and 4B are flowcharts showing, respectively, portions 400A and 400B of an exemplary processing flow for protecting membership privacy in secure multi-party computing and communications, according to at least some embodiments described herein.

[0067] Figures 5A to 5F show the progressing portion (500A to 500F) of a schematic diagram illustrating an example of the processing flow of Figures 4A and 4B according to at least some embodiments described herein.

[0068] It should be understood that the processing flows (400A and 400B) disclosed herein may be carried out by one or more processors (e.g., the processors of one or more terminal devices among terminal devices 110, 120, 130, and 140 in Figure 1, the processor of server 150 in Figure 1, the central processor unit 605 in Figure 6, and / or any other suitable processor) unless otherwise specified.

[0069] Furthermore, the processing flows (400A and 400B) may include one or more operations, behaviors, or functions, as indicated by one or more of blocks 405, 410, 415, 420, 425, 430, 435, 440, 445, 450, 455, 460, and 465. These various operations, behaviors, or actions may correspond, for example, to processor-executable software, program code, or program instructions that cause these functions to be performed. Although shown as discrete blocks, obvious modifications may be made depending on the desired implementation, for example, two or more blocks may be rearranged, more blocks may be added, and various blocks may be split into additional blocks, combined into fewer blocks, or removed. It should be understood that operations, including initialization, may be performed before the processing flows (400A and 400B). For example, system parameters and / or application parameters may be initialized. Processing flows (400A and 400B) may be initiated in block 405.

[0070] In block 405 (determining size), the processor may determine a dataset size N (i.e., number) to be used to generate a padding / filled dataset in order to achieve a desired membership privacy protection objective or performance (described in further detail below). It should be understood that the size N is determined to ensure that membership privacy settings and / or privacy requirements are met or satisfied. In embodiments, such membership privacy settings and / or privacy requirements may include settings and / or requirements (described in further detail below) defined in a differential privacy protocol or algorithm. Processing may proceed from block 405 to block 410.

[0071] In block 410 (Padding Set Generation), the processor of each device may provide a dataset for party A (e.g., 502A in Figure 5A) and / or provide a dataset for party B (e.g., 502B). It should be understood that the operations or functions described in the processing flows (400A and 400B) may be symmetric for party A and party B. It should be understood that the format, content and / or arrangement of the datasets described herein are for illustrative purposes only and are not intended to be limiting.

[0072] In one exemplary embodiment, dataset 502A may have two or more ID fields (ID columns: idA1, idA2, idA3, etc.) and / or may have or may not have one or more features or attributes (columns) associated with these ID fields. In one exemplary embodiment, ID field idA1 may represent a username, ID field idA2 may represent an email address, and ID field idA3 may represent a telephone number.

[0073] In one exemplary embodiment, dataset 502B may have two or more ID fields (ID columns: idB1, idB2, idB3, etc.) and / or may have or may not have one or more features or attributes (columns) associated with these ID fields. In one exemplary embodiment, ID field idB1 may represent a username, ID field idB2 may represent an email address, and ID field idB3 may represent a telephone number.

[0074] For each ID field in dataset 502A (from the first ID field idA1 to the last ID field idA3) and / or 502B (from the first ID field idB1 to the last ID field idB3), the processor may generate the respective fields (e.g., idD1, idD2, idD3, etc.) in dataset (e.g., 504A and / or 504B in Figure 5A). The dataset (504A or 504B) may be a padding or fill dataset that is used or shared in common by both Party A and Party B (e.g., the processor may provide Party B with a local copy 504B of dataset 504A, and Party A with a local copy 504A of dataset 504B). In one exemplary embodiment, each of the datasets (504A, 504B) has a size of 2*N (see description in block 405). In other exemplary embodiments, each of the datasets (504A, 504B) may have a size of N or more.

[0075] It should be understood that the size of a dataset (e.g., 504A or 504B) may refer to the number of records (or rows, elements, etc.) in the dataset (e.g., 504A or 504B). It should also be understood that if each of the datasets (504A, 504B) has a size of 2*N, then subsequent operations, such as PSI or MPC operations on the upsampled datasets (e.g., 508A in Figure 5A for Party A and 508B in Figure 5A for Party B, as described in more detail below), can be guaranteed to be (ε,δ) differentially confidential (as described and / or defined below) for both Party A and / or Party B. In exemplary embodiments, ε and / or δ may be predetermined to achieve desired membership privacy protection objectives or performance.

[0076] Features in embodiments disclosed herein (e.g., a determined size N) may be "(ε,δ)-differentially confidential" with respect to predetermined ε and δ (i.e., "differentially confidential" based on ε and δ). That is, the size N may be determined based on predetermined ε and δ so that it is "(ε,δ)-differentially confidential" with respect to subsequent operations, such as PSI or MPC operations on an upsampled dataset (i.e., the subsequent operations are "differentially confidential" based on ε and δ).

[0077] It should be understood that the above settings or requirements for a differential privacy protocol or algorithm may refer to a measure of "how much data privacy is granted (e.g., by querying on an input dataset) in order to perform an operation or function." The measurable set E may refer to all potential outputs of the predictable M. The first parameter "ε" may refer to the privacy budget (i.e., the limit on how much privacy leakage is acceptable), which represents, for example, the maximum difference between a query on dataset A and the same query on dataset A'. A smaller value of ε indicates stronger privacy protection for the multi-identity privacy protection mechanism. The second parameter "δ" may refer to a probability, such as the probability of information being leaked by chance. In an exemplary embodiment, the required or predetermined range of ε may be about 1 to about 3. The requested or predetermined range of δ may be about 10 -10 (or about 10 -8 ) from about 10 -6 It may also be the case that, in order to achieve, satisfy, or guarantee the requirement of (ε,δ) differential confidentiality, the value of N may be several thousand or approximately several thousand.

[0078] In one exemplary embodiment, the relationship between ε, δ, and N may be determined by a pre-determined or predefined algorithm. That is, the size N may be determined, for example, based on a requested or pre-determined ε and δ according to a pre-calibrated or pre-determined noise distribution, so that "(ε,δ) difference-secretive" can be achieved for subsequent operations, such as PSI or MPC operations on an upsampled dataset.

[0079] Furthermore, it should be understood that the datasets (504A, 504B) are generated such that the intersection of the ID field (idD1) in dataset (504A or 504B) and its corresponding ID field (idA1 or idB1) in dataset 502A for party A and dataset 502B for party B is empty (i.e., the result of an inner join operation) (i.e., the size is zero), the intersection of the ID field (idD2) in dataset (504A or 504B) and its corresponding ID field (idA2 or idB2) in dataset 502A for party A and dataset 502B for party B is empty (i.e., the size is zero), and the intersection of the ID field (idD3) in dataset (504A or 504B) and its corresponding ID field (idA3 or idB3) in dataset 502A for party A and dataset 502B for party B is empty (i.e., the size is zero). That is, there are no common or shared elements between idD1 and idA1 (and / or idD1 and idB1), no common or shared elements between idD2 and idA2 (and / or idD2 and idB2), and no common or shared elements between idD3 and idA3 (and / or idD3 and idB3). Processing may proceed from block 410 to block 415.

[0080] In block 415 (Shuffling of Padding Sets), the processor of each device may independently shuffle (e.g., randomly rearrange) each ID field (idD1, idD2, and idD3) of the datasets (504A, 504B) for party A and party B to generate the corresponding shuffled dataset for party A (e.g., 506A in Figure 5A) and the corresponding shuffled dataset for party B (e.g., 506B in Figure 5A). Processing may proceed from block 415 to block 420.

[0081] In block 420 (data setup sampling), for each ID field (from the first ID field (idA1 or idB1) to the last ID field (idA3 or idB3)) in the dataset 502A for party A and the dataset 502B for party B, the processor of each device may upsample the corresponding ID fields in the dataset 502A for party A and / or the dataset 502B for party B. It should be understood that upsampling of the corresponding ID fields in dataset 502A may include (1) selecting or retrieving the first N elements (or records, rows, etc.) of each ID field (idD1, idD2, idD3) in dataset 506A; (2) generating the union of the corresponding ID fields in dataset 502A and the first N elements of each ID field (idD1, idD2, idD3) in dataset 506A (resulting in the corresponding ID fields in dataset 508A shown in Figure 5A); and (3) inserting N random numbers / elements into other fields in dataset 508A that are in the same records / rows as the added / inserted / appended first N elements of each ID field (idD1, idD2, idD3) in dataset 506A.

[0082] For example, as shown in Figure 5A, N is determined to be 2 in block 405. For idA1 in dataset 502A, the first N elements (or records, rows, etc.) of the ID field idD1 in dataset 506A are selected or retrieved. The union of the first N elements of the ID field idD1 in dataset 506A and the idA1 field in dataset 502A is generated and becomes the idA1 field in dataset 508A. N random numbers / elements are inserted into each of the other fields (idA2, idA3, etc.) in dataset 508A that are in the same record / row as the first N elements added / inserted / appended in the ID field idD1 of dataset 506A. It should be understood that one of these N random numbers / elements will have an empty intersection with any other element in dataset 508A resulting from party A, and an empty intersection with any element in the upsampled dataset 508B resulting from party B.

[0083] For idA2 in dataset 502A, the first N elements (or records, rows, etc.) of the ID field idD2 in dataset 506A are selected or retrieved. The union of the first N elements of the ID field idD2 in dataset 506A and the idA2 field in dataset 502A (extended by the inserted 1*N random numbers / elements) is generated and becomes the idA2 field in dataset 508A. The N random numbers / elements are inserted into each of the other fields in dataset 508A (idA1, idA3, etc.) that are in the same record / row as the first N elements added / inserted / appended in the ID field idD2 of dataset 506A. It should be understood that any one of these N random numbers / elements will have an empty intersection with any other element in dataset 508A resulting from party A, and an empty intersection with any element in the upsampled dataset 508B resulting from party B.

[0084] For idA3 in dataset 502A, the first N elements (or records, rows, etc.) of the ID field idD3 in dataset 506A are selected or retrieved. The union of the first N elements of the ID field idD3 in dataset 506A and the idA3 field in dataset 502A (extended by the inserted 1*N random numbers / elements) is generated and becomes the idA3 field in dataset 508A. The N random numbers / elements are inserted into each of the other fields in dataset 508A (idA1, idA2, etc.) that are in the same record / row as the first N elements added / inserted / appended in the ID field idD3 of dataset 506A. It should be understood that any one of these N random numbers / elements will have an empty intersection with any other element in dataset 508A resulting from party A, and an empty intersection with any element in the upsampled dataset 508B resulting from party B.

[0085] It should also be understood that the upsampled dataset 508A may be used as dataset 310A in Figure 3. Similarly, the ID fields (idB1, idB2, idB3) of dataset 502B for party B may be upsampled using the independently shuffled ID fields (idD1, idD2, idD3) of dataset 506B to generate an upsampled dataset (e.g., 508B in Figure 5A or 310B in Figure 3).

[0086] It should be understood that the processor of each device may process the upsampled dataset 508A for Party A and / or the upsampled dataset 508B for Party B to generate a common portion for further processing (without exposing the actual size of the common portion, as padding / filling elements and random numbers / elements are inserted into the upsampled datasets for Party A and / or Party B). Furthermore, by introducing the datasets (504A, 504B) and random numbers / elements for upsampling, the size of the common portion between the upsampled dataset 508A for Party A and the upsampled dataset 508B for Party B does not expose the actual common portion size of the original datasets (e.g., 502A for Party A and 502B for Party B). That is, the features of the embodiments disclosed herein make it possible to make the common portion size exposed in subsequent PSI or MPC operations random and differentially confidential, making it virtually impossible for an attacker to determine a user's membership based on the size of the common portion.

[0087] As shown in Figure 5A, in an exemplary embodiment, dataset 508A includes multiple records (rows), each record including a first member or user identifier (idA1), a second member or user identifier (idA2), and a third member or user identifier (idA3). Dataset 508B includes multiple records (rows), each record including a first member or user identifier (idB1), a second member or user identifier (idB2), and a third member or user identifier (idB3). It should be understood that the format, content, and / or arrangement of datasets 508A and / or 508B are for illustrative purposes only and are not intended to be limiting. For example, each dataset 508A or 508B may have one or more IDs (columns) and / or zero or one or more features or attributes (columns) associated with such one or more IDs.

[0088] It should be understood that, for various reasons, Party A and / or Party B may not wish to disclose to the other party at least some of the data in dataset 508A and / or dataset 508B, and / or the data in the common portion of dataset 508A and dataset 508B, respectively. Processing may proceed from block 420 to block 425.

[0089] In block 425 (Shuffling and Transformation), the processor may transform the ID fields (columns, idA1, idA2, and idA3) of dataset 508A (to obtain or generate dataset 505A in Figure 5B) using a transformation scheme for party A. It should be understood that the function or operation to "transform" or "transform" one or more columns (or rows) of a dataset, such as one or more identification fields / columns (or records / rows), may also mean processing (e.g., encryption, decryption, encoding, decryption, manipulation, compression, decompression, transformation, etc.) the dataset or part thereof. "Transformation scheme" may also mean an algorithm, protocol, or function that performs processing (e.g., encryption, decryption, encoding, decryption, manipulation, compression, decompression, transformation, etc.) of the dataset or part thereof. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, convert, etc.) the ID of dataset 508A (to obtain or generate dataset 505A) using, for example, the key of party A, based on an ECDH algorithm or protocol (represented by function D0(.)).

[0090] The processor may also transform the ID fields (idB1, idB2, and idB3) of dataset 508B (to obtain or generate dataset 505B in Figure 5B) using a transformation scheme for party B. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decode, manipulate, compress, decompress, transform, etc.) the IDs of dataset 508B (to obtain or generate dataset 505B) using, for example, party B's key, based on an ECDH algorithm or protocol (represented by function D1(.)).

[0091] The processor in each device may shuffle dataset 505A for party A (e.g., by random rearrangement) and / or shuffle dataset 505B for party B.

[0092] In block 425, the order of dataset transformation and dataset shuffling may be switched or changed for party A and / or party B without affecting the purpose of the resulting dataset. For example, the processor may shuffle dataset 508A and then transform the shuffled dataset to obtain or generate dataset 505A for party A. The processor may also shuffle dataset 508B and then transform the shuffled dataset to obtain or generate dataset 505B for party B. Processing may proceed from block 425 to block 430.

[0093] In block 430 (exchange, shuffling, and transformation), the processor of each device may exchange (shuffled) dataset 505A and (shuffled) dataset 505B between party A and party B. For party A, the processor may dispatch or transmit (shuffled) dataset 505A to party B and receive or acquire (shuffled) dataset 505B from party B as dataset 510A (see Figure 5B). For party B, the processor may dispatch or transmit (shuffled) dataset 505B to party A and receive or acquire (shuffled) dataset 505A from party A as dataset 510B (see Figure 5B). It should be understood that because datasets 505A and 505B have already been transformed (e.g., encoded), the corresponding receiving party may not know the actual data in the received dataset.

[0094] The processor may further transform the ID field (idB1) of dataset 510A using a transformation scheme for party A. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, convert, etc.) the ID (idB1) of dataset 510A using party A's key based on an ECDH algorithm or protocol (represented by function D0(.)). The processor may further transform the ID field (idA1) of dataset 510B using a transformation scheme for party B. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, convert, etc.) the ID field (idA1) of dataset 510B using party B's key based on an ECDH algorithm or protocol (represented by function D1(.)). It should be understood that the results of functions D1(D0(p)) and D0(D1(p)) may be the same for the same parameter "p".

[0095] The processor may also shuffle dataset 510A for party A and / or shuffle dataset 510B for party B. In block 430, the order of transforming the ID field of the dataset and shuffling the dataset may be switched or changed for party A and / or party B without affecting the purpose of the resulting dataset. For example, the processor may shuffle dataset 510A and then transform the shuffled dataset 510A for party A. The processor may also shuffle dataset 510B and then transform dataset 510B for party B. Processing may proceed from block 430 to block 435.

[0096] In block 435 (transformation and matching), the processor of each device may extract the ID field (idA1) of the (shuffled) dataset 510B to obtain or generate dataset 515A for party A, and / or extract the ID field (idB1) of the (shuffled) dataset 510A to obtain or generate dataset 515B for party B. The processor of each device may also exchange the extracted dataset 510A (shuffled idB1 field) with the extracted dataset 510B (shuffled idA1 field) between party A and party B. For party A, the processor may dispatch or send the extracted dataset 510A (shuffled idB1 field) to party B, and receive or obtain the extracted dataset 510B (shuffled idA1 field) from party B as dataset 515A. With respect to Party B, the processor may dispatch or send the extracted dataset 510B (the idA1 field after shuffling) to Party A, and receive or acquire the extracted dataset 510A (the idB1 field after shuffling) from Party A as dataset 515B.

[0097] The processor may also perform a search for matching (or an inner join operation, etc.) between dataset 510A and dataset 515A to obtain or generate a common part (dataset 520A in Figure 5C) for party A. It should be understood that the above operations include, for each identifier in dataset 515A that matches an identifier in dataset 510A, adding or appending the record (or row) in dataset 510A containing the matched identifier to dataset 520A, and removing the record (or row) containing the matched identifier from dataset 510A to obtain or generate the resulting dataset 525A.

[0098] The processor may also perform a search for matching (or an inner join operation, etc.) between dataset 510B and dataset 515B to obtain or generate a common part (dataset 520B in Figure 5C) for party B. It should be understood that the above operations include, for each identifier in dataset 515B that matches an identifier in dataset 510B, adding or appending the record (or row) in dataset 510B containing the matched identifier to dataset 520B, and removing the record (or row) containing the matched identifier from dataset 510B to obtain or generate the resulting dataset 525B.

[0099] In one exemplary embodiment, it should be understood that the idB2 and idB3 fields in dataset / common section 520A may be optional because the matching is based on idB1 (which has a higher priority than idB2 and idB3). The idA2 and idA3 fields in dataset / common section 520B may also be optional because the matching is based on idA1 (which has a higher priority than idA2 and idA3). Additionally, dataset 525A contains all unmatched records (rows) from dataset 510A. Dataset 525B contains all unmatched records (rows) from dataset 510B.

[0100] It should be understood that for Party A, the data in the common section 520A is also transformed (e.g., encoded) by Party B (e.g., via D1(.)), so Party A may not know the actual data in the common section 520A. For Party B, the data in the common section 520B is also transformed (e.g., encoded) by Party A (e.g., via D0(.)), so Party B may not know the actual data in the common section 520B. In other words, the matching or inner join operation performed as described above is a "confidential" matching or inner join operation. The processor performs confidential identity matching without revealing the common section of the datasets of these two parties. Processing may proceed from block 435 to block 440.

[0101] In block 440 (transformation, shuffling, and exchange), the processor of each device may transform the ID field (column, idB2) of dataset 525A (to obtain or generate dataset 530A in Figure 5C) using a transformation scheme for party A. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decode, manipulate, compress, decompress, transform, etc.) the ID field idB2 of dataset 525A (to obtain or generate dataset 530A) using, for example, another key of party A, based on an ECDH algorithm or protocol (represented by function D3(.)).

[0102] The processor may also transform the ID field (idA2) of dataset 525B (to obtain or generate dataset 530B in Figure 5C) using a transformation scheme for party B. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decode, manipulate, compress, decompress, transform, etc.) the ID field idA2 of dataset 525B (to obtain or generate dataset 530B) using, for example, another key of party B, based on an ECDH algorithm or protocol (represented by function D4(.)).

[0103] The processor in each device may shuffle dataset 530A for party A (e.g., by random rearrangement) and / or shuffle dataset 530B for party B. The processor in each device may also record, save, retain, or otherwise maintain the shuffled rearrangement of dataset 530A and / or the shuffled rearrangement of dataset 530B (in preparation for the unshuffling process in block 445).

[0104] In block 440, the order of dataset transformation and dataset shuffling may be switched or changed for party A and / or party B, without affecting the purpose of the resulting dataset. For example, the processor may shuffle dataset 530A and then transform the shuffled dataset 530A for party A. The processor may also shuffle dataset 530B and then transform the shuffled dataset 530B for party B.

[0105] The processor in each device may exchange (shuffled) dataset 530A and (shuffled) dataset 530B between party A and party B. For party A, the processor may dispatch or transmit (shuffled) dataset 530A to party B and receive or acquire (shuffled) dataset 530B from party B as dataset 535A (see Figure 5C). For party B, the processor may dispatch or transmit (shuffled) dataset 530B to party A and receive or acquire (shuffled) dataset 530A from party A as dataset 535B (see Figure 5C). It should be understood that because datasets 530A and 530B have already been transformed (e.g., encoded), the corresponding receiving party may not know the actual data in the received dataset. Processing may proceed from block 440 to block 445.

[0106] In block 445 (transformation, exchange, unshuffling, and matching), the processor of each device may transform dataset 535A (to obtain or generate dataset 540A in Figure 5D) using a transformation scheme for party A. In one exemplary embodiment, the processor may decrypt (or encrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 535A using, for example, party A's key, based on an ECDH algorithm or protocol (represented by function D0(.)), and then encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 535A using, for example, another key of party A, based on an ECDH algorithm or protocol (represented by function D3(.)). That is, dataset 535A is untransformed (e.g., key D0(.) is removed), and then transformed again (key D3(.) is added) to obtain or generate dataset 540A.

[0107] The processor may also transform dataset 535B (to obtain or generate dataset 540B in Figure 5D) using a transformation scheme for party B. In one exemplary embodiment, the processor may decrypt (or encrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 535B using, for example, party B's key, based on an ECDH algorithm or protocol (represented by function D1(.)), and then encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 535B using, for example, another key of party B, based on an ECDH algorithm or protocol (represented by function D4(.)). That is, the transformation of dataset 535B is undone (e.g., key D1(.) is removed), and then transformed again (key D4(.) is added) to obtain or generate dataset 540B. It should be understood that the results of functions D3(D4(p)) and D4(D3(p)) may be the same for the same parameter "p".

[0108] The processor of each device may exchange dataset 540A and dataset 540B between party A and party B. For party A, the processor may dispatch or transmit dataset 540A to party B and receive or acquire dataset 540B from party B as dataset 545A (see Figure 5D). For party B, the processor may dispatch or transmit dataset 540B to party A and receive or acquire dataset 540A from party A as dataset 545B (see Figure 5D).

[0109] The processor of each device may unshuffle dataset 545A for party A so that the records (rows) in dataset 545A and dataset 530A have the same order or sequence (other than the conversion method used for records / rows), based on the sorting (of the shuffling of dataset 530A) maintained in block 440. The processor of each device may also unshuffle dataset 545B for party B so that the records (rows) in dataset 545B and dataset 530B have the same order or sequence (other than the conversion method used for records / rows), based on the sorting (of the shuffling of dataset 530B) maintained in block 440.

[0110] The processor of each device may perform a search for matching (or an internal join operation, etc.) between dataset 540A and dataset 545A to obtain or generate a common part (dataset 550A in Figure 5D) for party A. It should be understood that the above operation involves adding or appending the record (or row) from dataset 545A containing the matched identifier to dataset 550A for each identifier in dataset 545A that matches an identifier in dataset 540A; adding or appending the remaining ID fields (e.g., idB1, idB3) from the corresponding record (or row) in dataset 525A to dataset 550A; and removing the corresponding record (or row) from dataset 525A to obtain or generate the resulting dataset 555A. It should be understood that, since the records in dataset 545A have the same order or sequence as the records in dataset 530A (extracted from dataset 525A), the remaining ID fields (e.g., idB1, idB3) of the corresponding records (or rows) in dataset 525A are associated with the corresponding IDs in dataset 545A. It should also be understood that, for dataset 550A, the ID field idB3 may be optional because the matching is based on idB2. Similarly, for dataset 555A, the ID field idB1 may be optional because the matching is based on idB2.

[0111] The processor may also perform a search for matching (or an inner join operation, etc.) between dataset 540B and dataset 545B to obtain or generate a common part (dataset 550B in Figure 5D) for party B. It should be understood that the above operations include, for each identifier in dataset 545B that matches an identifier in dataset 540B, adding or appending the record (or row) in dataset 545B containing the matched identifier to dataset 550B; adding or appending the remaining ID fields (e.g., idA1, idA3) from the corresponding record (or row) in dataset 525B to dataset 550B; and removing the corresponding record (or row) in dataset 525B to obtain or generate the resulting dataset 555B. It should be understood that, since the records in dataset 545B have the same order or sequence as the records in dataset 530B (extracted from dataset 525B), the remaining ID fields (e.g., idA1, idA3) of the corresponding records (or rows) in dataset 525B are associated with the corresponding IDs in dataset 545B. It should also be understood that, for dataset 550B, the ID field idA3 may be optional because the matching is based on idA2. Similarly, for dataset 555B, the ID field idA1 may be optional because the matching is based on idA2.

[0112] In one exemplary embodiment, the idB1 field in dataset / common section 550A may also be optional, since the matching is based on idB2 (after idB1 is unmatched in dataset 525A). The idA1 field in dataset / common section 550B may also be optional, since the matching is based on idA2 (after idA1 is unmatched in dataset 525B).

[0113] It should be understood that for Party A, the data in the common section 550A is also transformed (e.g., encoded) by Party B (e.g., via D4(.)), so Party A may not know the actual data in the common section 550A. For Party B, the data in the common section 550B is also transformed (e.g., encoded) by Party A (e.g., via D3(.)), so Party B may not know the actual data in the common section 550B. In other words, the matching or inner join operation performed as described above is a "confidential" matching or inner join operation. The processor performs confidential identity matching without revealing the common section of the datasets of these two parties. Processing may proceed from block 445 to block 450.

[0114] In block 450 (transformation, shuffling, and exchange), the processor of each device may transform the ID field (column, idB3) of dataset 555A (to obtain or generate dataset 560A in Figure 5E) using a transformation scheme for party A. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decode, manipulate, compress, decompress, transform, etc.) the ID field idB3 of dataset 555A (to obtain or generate dataset 560A) using, for example, yet another key of party A, based on an ECDH algorithm or protocol (represented by function D5(.)).

[0115] The processor may also transform the ID field (idA3) of dataset 555B (to obtain or generate dataset 560B in Figure 5E) using a transformation scheme for party B. In one exemplary embodiment, the processor may encrypt (or decrypt, encode, decode, manipulate, compress, decompress, transform, etc.) the ID field idA3 of dataset 555B (to obtain or generate dataset 560B) using, for example, yet another key of party B, based on an ECDH algorithm or protocol (represented by function D6(.)).

[0116] The processor in each device may shuffle dataset 560A for party A (e.g., by random rearrangement) and / or shuffle dataset 560B for party B.

[0117] In block 450, the order of dataset transformation and dataset shuffling may be switched or changed for party A and / or party B without affecting the purpose of the resulting dataset. For example, the processor may shuffle dataset 560A and then transform the shuffled dataset 560A for party A. The processor may also shuffle dataset 560B and then transform the shuffled dataset 560B for party B.

[0118] The processor in each device may exchange (shuffled) dataset 560A and (shuffled) dataset 560B between party A and party B. For party A, the processor may dispatch or transmit (shuffled) dataset 560A to party B and receive or acquire (shuffled) dataset 560B from party B as dataset 565A (see Figure 5E). For party B, the processor may dispatch or transmit (shuffled) dataset 560B to party A and receive or acquire (shuffled) dataset 560A from party A as dataset 565B (see Figure 5E). It should be understood that because datasets 560A and 560B have already been transformed (e.g., encoded), the corresponding receiving party may not know the actual data in the received dataset. Processing may proceed from block 450 to block 455.

[0119] In block 455 (transformation and exchange), the processor of each device may transform dataset 565A (to obtain or generate dataset 570A in Figure 5E) using a transformation scheme for party A. In one exemplary embodiment, the processor may decrypt (or encrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 565A using, for example, party A's key, based on an ECDH algorithm or protocol (represented by function D0(.)), and then encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 565A using, for example, another key of party A, based on an ECDH algorithm or protocol (represented by function D5(.)). That is, the transformation of dataset 565A is undone (e.g., key D0(.) is removed), and then transformed again (key D5(.) is added) to obtain or generate dataset 570A.

[0120] The processor may also transform dataset 565B (to obtain or generate dataset 570B in Figure 5E) using a transformation scheme for party B. In one exemplary embodiment, the processor may decrypt (or encrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 565B using, for example, party B's key, based on an ECDH algorithm or protocol (represented by function D1(.)), and then encrypt (or decrypt, encode, decrypt, manipulate, compress, decompress, transform, etc.) dataset 565B using, for example, yet another key of party B, based on an ECDH algorithm or protocol (represented by function D6(.)). That is, dataset 565B is untransformed (e.g., key D1(.) is removed), and then transformed again (key D6(.) is added) to obtain or generate dataset 570B. It should be understood that the results of functions D5(D6(p)) and D6(D5(p)) may be the same for the same parameter "p".

[0121] The processor of each device may exchange dataset 570A and dataset 570B with party A and party B. For party A, the processor may dispatch or transmit dataset 570A to party B and receive or acquire dataset 570B from party B as dataset 575A (see Figure 5E). For party B, the processor may dispatch or transmit dataset 570B to party A and receive or acquire dataset 570A from party A as dataset 575B (see Figure 5E). Processing may proceed from block 455 to block 460.

[0122] In block 460 (Matching and Joining), the processor of each device may perform a search for matching (or an internal join operation, etc.) between dataset 570A and dataset 575A to obtain or generate a common part (dataset 580A in Figure 5E) for party A. It should be understood that the above operation includes adding or appending the record (or row) from dataset 575A containing the matched identification for each identification in dataset 575A that matches the identification in dataset 570A to dataset 580A. It should also be understood that for dataset 580A, the ID fields idB1 and idB2 may be optional because the matching is based on idB3 (after idB1 and idB2 have been unmatched).

[0123] The processor may also perform a search for matching (or an inner join operation, etc.) between dataset 570B and dataset 575B to obtain or generate a common part (dataset 580B in Figure 5E) for party B. It should be understood that the above operation includes adding or appending the record (or row) from dataset 575B containing the matched identification for each identification in dataset 575B that matches an identification in dataset 570B to dataset 580B. It should also be understood that for dataset 580B, the ID fields idA1 and idA2 may be optional because the matching is based on idA3 (after idA1 and idA2 have been dismatched).

[0124] It should be understood that for Party A, the data in the common portion 580A is also transformed (e.g., encoded) by Party B (e.g., via D6(.)), so Party A may not know the actual data in the common portion 580A. For Party B, the data in the common portion 580B is also transformed (e.g., encoded) by Party A (e.g., via D5(.)), so Party B may not know the actual data in the common portion 580B. In other words, the matching or inner join operation performed as described above is a "confidential" matching or inner join operation. The processor performs confidential identity matching without revealing the common portion of the datasets of these two parties.

[0125] The processor of each device may, for party A, combine the records / rows of datasets 520A, 550A, and 580 to obtain or generate dataset 585A. It should be understood that in dataset 585A, a blank value for idB3 indicates that such a value is not important (because a higher priority ID field, idB1 or idB2, matched), a blank value for idB2 indicates that such a value is not important (because a higher priority ID field, idB1, matched, or because ID fields idB1 and idB2 did not match, but ID field idB3 matched, and the matched record is for the same user / member), and a blank value for idB1 indicates that such a value is not important (because ID field idB1 did not match, but ID field idB2 did, or because ID field idB2 did not match, but ID field idB3 matched, and the matched record is for the same user / member).

[0126] The processor of each device may also combine the records / rows of datasets 520B, 550B, and 580B for party B to obtain or generate dataset 585B. It should be understood that in dataset 585B, a blank value for idA3 indicates that such a value is not important (because a higher priority ID field idA1 or idA2 matched), a blank value for idA2 indicates that such a value is not important (because a higher priority ID field idA1 matched, or because ID fields idA1 and idA2 did not match, but ID field idA3 matched, and the matched records are for the same user / member), and a blank value for idA1 indicates that such a value is not important (because ID field idA1 did not match, but ID field idA2 did, or because ID field idA2 did not match, but ID field idA3 matched, and the matched records are for the same user / member). Processing may proceed from block 460 to block 465.

[0127] In block 466 (data sort post-processing), the processor of each device may process dataset 585A for party A and / or dataset 585B for party B for further applications. It should be understood that by introducing datasets (504A / 506A and / or 504B / 506B) and / or random numbers / elements to upsample the original datasets (502A and 502B), the size of the intersection of the upsampled datasets (508A and 508B) (i.e., dataset 585A for party A or dataset 585B for party B) does not expose the actual intersection size of the original datasets (e.g., 502A for party A and 502B for party B).

[0128] In the common section 585A or 585B, each ID field has a size greater than (or less than) the size of the corresponding ID field in the common section of the original datasets (502A and 502B). For example, the size of the IdA1 or idB1 field in the common section of the original datasets (502A and 502B) is 3 (three records, rows, elements, etc., including "g", "c", and "e"), while the size of the IdA1 or idB1 field in dataset / common section 585A or 585B is 4 (i.e., the size of the IdA1 or idB1 field in the common section of datasets 502A and 502B plus a random element "&1" resulting from introducing datasets 504A and / or 504B for upsampling). The size of the IdA2 or idB2 field in the intersection of the original datasets (502A and 502B) is 1 (one record, row, element, etc., including "#"), and the size of the IdA2 or idB2 field in dataset / intersection 585A or 585B is 2 (i.e., the size of the IdA2 or idB2 field in the intersection of datasets 502A and 502B plus a random element "$2" by introducing datasets 504A and / or 504B for upsampling). The size of the IdA3 or idB3 field in the intersection of the original datasets (502A and 502B) is 1 (containing "9", such as one record, row, or element), while the size of the IdA3 or idB3 field in dataset / intersection 585A or 585B is 2 (i.e., the size of the IdA3 or idB3 field in the intersection of datasets 502A and 502B plus a random element "&3" resulting from introducing datasets 504A and / or 504B for upsampling).

[0129] In other words, another feature of the embodiments disclosed herein is that the common portion size exposed in subsequent multi-identity PSI and / or MPC operations is random and differentially concealed, making it virtually impossible for an attacker to determine the user's membership.

[0130] In one exemplary embodiment, one or more of the datasets or common parts 585A and 585B may include one or more features or attributes (i.e., columns that are not identification information). The processor of each device may generate, collect, and / or combine the collected confidential shares for party A, party B, or both, based on the IDs and / or features or attributes of datasets 585A and / or 585B to produce the result.

[0131] Figure 6 is a schematic diagram of an exemplary computer system 600 applicable to realizing an electronic device (e.g., one of the servers or terminal devices shown in Figure 1), arranged according to at least some embodiments described herein. It should be understood that the computer system shown in Figure 6 is provided for illustrative purposes only and does not limit the functions and applications of the embodiments described herein.

[0132] As shown in the figure, the computer system 600 may include a central processing unit (CPU) 605. The CPU 605 may perform various operations and processes based on programs stored in read-only memory (ROM) 610 or programs loaded from storage device 640 into random access memory (RAM) 615. The RAM 615 may also store various data and programs required for the operation of the system 600. The CPU 605, ROM 610, and RAM 615 may be connected to each other via a bus 620. An input / output (I / O) interface 625 may also be connected to the bus 620.

[0133] The components connected to the I / O interface 625 may further include an input device 630, such as a keyboard, mouse, digital pen, or drawing pad; an output device 635, such as a display like a liquid crystal display (LCD) or a speaker; a storage device 640, such as a hard disk; and a communication device 645, such as a network interface card like a LAN card or a modem. The communication device 645 may perform communication processing via a network, such as the Internet, WAN, LAN, LINE, or cloud. In one embodiment, a driver 650 may also be connected to the I / O interface 625. A removable medium 655, such as a magnetic disk, optical disk, magneto-optical disk, or semiconductor memory, may be mounted to the driver 650 as needed so that a computer program read from the removable medium 655 may be installed in the storage device 640.

[0134] It should be understood that the processes described with reference to the flowcharts in Figures 2, 4A and 4B and / or the processes described in other figures may be implemented as a computer software program or in hardware. The computer program product may include a computer program stored on a computer-readable non-volatile medium. The computer program includes program code for performing the methods shown in the flowcharts and / or GUI. In this embodiment, the computer program may be downloaded and installed from a network via the communication device 645, or it may be installed from a removable medium 655. When the computer program is executed by the central processing unit (CPU) 605, it can perform the functions defined in the methods in the embodiments disclosed herein.

[0135] It should be understood that the disclosed and other solutions, examples, embodiments, modules, and functional operations described herein may be implemented within digital electronic circuits, or within computer software, firmware, or hardware, including the structures disclosed herein and their structural equivalents, or within one or more combinations thereof. The disclosed embodiments and other embodiments may be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer-readable medium, to be executed by or to control the operation of a data processing device. The computer-readable medium may be a machine-readable storage device, a machine-readable storage board, a memory device, a composition of a material that affects machine-readable propagating signals, or one or more combinations thereof. "Data processing device" includes all equipment, devices, and machines for processing data, including, for example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the device may include code that generates the execution environment of the computer program being discussed, such as processor firmware, a protocol stack, a database management system, an operating system, or code that constitutes one or more combinations thereof.

[0136] Computer programs (also referred to as programs, software, software applications, scripts, or code) may be written in any form of programming language, including compiled or interpreted languages, and may be deployed in any form, as standalone programs or as modules, components, subroutines, or other units suitable for use in a computing environment. Computer programs do not necessarily correspond to files in a file system. A program may be stored in part of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program, or in a group of collaborative files (e.g., a file containing one or more modules, subprograms, or parts of code). Computer programs may be deployed to run on one computer, located in one site, or distributed across multiple sites and interconnected by a communication network.

[0137] The processing and logic flows described herein can perform their functions by manipulating input data and generating outputs, which are executed by one or more programmable processors running one or more computer programs. The processing and logic flows may also be executed by dedicated logic circuits, such as field-programmable gate arrays and application-specific integrated circuits, and devices may also be implemented as such.

[0138] Processors suitable for executing computer programs include, for example, both general-purpose microprocessors and dedicated microprocessors, and any one or more processors of any type of digital computer. Generally, a processor receives instructions and data from read-only memory or random-access memory or both. Essential elements of a computer are a processor for executing instructions and one or more storage devices for storing instructions and data. Generally, a computer also includes or is operablely coupled to one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks or optical disks, to receive or transfer data or both. However, a computer is not required to have such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including, for example, erasable programmable read-only memory, electrically erasable programmable read-only memory and semiconductor memory devices such as flash memory devices, magnetic disks such as internal hard disks or removable disks, magneto-optical disks and compact disk read-only memory and digital video disk read-only memory disks. The processor and memory may be complemented by dedicated logic circuits, or they may be incorporated into dedicated logic circuits.

[0139] It should be understood that different features, variations, and multiple different embodiments are illustrated and described in various details. In this application, what is described with respect to a particular embodiment is done for illustrative purposes only and is not intended to limit or suggest that what has been devised is only one specific embodiment or particular embodiment. It should be understood that this disclosure is not limited to any single specific embodiment or enumerated variation. A person skilled in the art will conceive of many modifications, variations, and other embodiments which are intended and actually covered by this disclosure. The scope of this disclosure is actually intended to be determined by the appropriate legal interpretation and structure of the disclosure, including equivalents, as a person skilled in the art will understand by relying on the complete disclosure available at the time of filing.

[0140] Pattern:

[0141] It will be understood that any one of the embodiments may be combined.

[0142] Appearance 1, A method for protecting membership in confidential multiparty computing and communications, comprising: providing a first dataset including a first identification field and a second identification field; generating a padding dataset whose size is determined based on data privacy settings; upsampling the first dataset using the padding dataset; transforming the first dataset; dispatching the first dataset; receiving a second dataset having a third identification field and a fourth identification field; generating a third dataset by performing an intersection operation on the first dataset and the second dataset, by removing rows from the second dataset and adding the removed rows to the third dataset for each identification in the first identification field that matches an identification in the third identification field; and removing rows from the second dataset and adding the removed rows to the third dataset for each identification in the second identification field that matches an identification in the fourth identification field.

[0143] Appearance 2, A method according to Embodiment 1, wherein the padding dataset includes a fifth identification information field and a sixth identification information field, and upsampling the first dataset using the padding dataset includes upsampling the first identification information field using elements in the fifth identification information field and inserting a first set of random elements into the second identification information field.

[0144] Appearance 3, A method according to Embodiment 2, wherein upsampling the first dataset using the padding dataset includes upsampling the second identification information field using elements in the sixth identification information field and inserting a second set of random elements into the first identification information field.

[0145] Appearance 4, A method according to any one of embodiments 1 to 3, further comprising shuffling the padding dataset before upsampling the first dataset using the padding dataset.

[0146] Appearance 5, A method according to any one of embodiments 1 to 4, wherein the intersection of the padding dataset and the first dataset is empty.

[0147] Appearance 6, The method according to any one of embodiments 1 to 5, wherein the first identification information field has a higher priority than the second identification information field, and the third identification information field has a higher priority than the fourth identification information field.

[0148] Appearance 7, A method according to any one of embodiments 1 to 6, wherein the data privacy setting includes a first parameter and a second parameter, and the size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter.

[0149] Appearance 8, The method according to embodiment 7, wherein the size of the padding dataset is determined based on the number of identification information fields of the first dataset.

[0150] Appearance 9, The method according to embodiment 8, wherein the size of the padding dataset is further determined based on the number of intersection operations.

[0151] Appearance 10, A method according to any one of embodiments 1 to 9, wherein the first dataset includes a seventh identification information field, the second dataset includes an eighth identification information field, and generating the third dataset by performing a set intersection operation on the first dataset and the second dataset further includes, for each identification information in the seventh identification information field that matches an identification information in the eighth identification information field, deleting the row having the matched identification information from the second dataset and adding the deleted row to the third dataset.

[0152] Embodiment 11, A confidential multiparty computing and communication system comprising: a memory for storing a first dataset; a processor which provides the first dataset including a first identification information field and a second identification information field, generates a padding dataset whose size is determined based on data privacy settings, upsamples the first dataset using the padding dataset, transforms the first dataset, dispatches the first dataset, receives a second dataset having a third identification information field and a fourth identification information field, and generates a third dataset by performing an intersection operation based on the first dataset and the second dataset, thereby removing rows from the second dataset and adding the removed rows to the third dataset for each identification information in the first identification information field that matches an identification information in the third identification information field; and removing rows from the second dataset and adding the removed rows to the third dataset for each identification information in the second identification information field that matches an identification information in the fourth identification information field.

[0153] Appearance 12, A system according to embodiment 11, wherein the padding dataset includes a fifth identification information field and a sixth identification information field, and the processor further upsamples the first identification information field using elements in the fifth identification information field and inserts a first set of random elements into the second identification information field.

[0154] Embodiment 13, A system according to embodiment 12, wherein the processor further upsamples the second identification information field using the elements in the sixth identification information field and inserts a second set of random elements into the first identification information field.

[0155] Appearance 14, A system according to any one of embodiments 11 to 13, wherein the processor further shuffles the padding dataset before upsampling the first dataset using the padding dataset.

[0156] Appearance 15, A system according to any one of embodiments 11 to 14, wherein the data privacy setting includes a first parameter and a second parameter, and the size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter.

[0157] Appearance 16, A non-temporary computer-readable medium storing computer-executable instructions, wherein when an instruction is executed, it provides one or more processors with a first dataset including a first identification information field and a second identification information field; generates a padding dataset whose size is determined based on data privacy settings; upsamples the first dataset using the padding dataset; transforms the first dataset; dispatches the first dataset; receives a second dataset having a third identification information field and a fourth identification information field; and the third The operation includes performing an intersection operation based on the first dataset and the second dataset to generate the third dataset by deleting rows from the second dataset and adding the deleted rows to the third dataset for each identifier in the first identifier field that matches the identifier in the identifier field, and deleting rows from the second dataset and adding the deleted rows to the third dataset for each identifier in the second identifier field that matches the identifier in the fourth identifier field, thereby generating the third dataset.

[0158] Appearance 17, A computer-readable medium according to embodiment 16, wherein the padding dataset includes a fifth identification information field and a sixth identification information field, and upsampling the first dataset using the padding dataset includes upsampling the first identification information field using elements in the fifth identification information field and inserting a first set of random elements into the second identification information field.

[0159] Appearance 18, A computer-readable medium according to embodiment 17, wherein upsampling the first dataset using the padding dataset further includes upsampling the second identification information field using elements in the sixth identification information field and inserting a second set of random elements into the first identification information field.

[0160] Appearance 19, A computer-readable medium according to any one of embodiments 16 to 18, wherein the operation further includes shuffling the padding dataset before upsampling the first dataset using the padding dataset.

[0161] Appearance 20, A computer-readable medium according to any one of embodiments 16 to 19, wherein the data privacy setting includes a first parameter and a second parameter, and the size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter.

[0162] The terms used herein are intended to describe, and not limit, specific embodiments. The terms “one,” “one,” and “the” include the plural form unless expressly indicated. The terms “includes” and / or “equipment,” as used herein, presuppose the presence of the described features, integers, steps, operations, elements, and / or components, but do not presuppose the presence or addition of one or more other features, integers, steps, operations, elements, and / or components.

[0163] It should be understood that, with respect to the above description, modifications may be made to details, particularly the materials used, shapes, sizes, and arrangements of components, without departing from the scope of this disclosure. The embodiments described herein and described herein are illustrative only, and the true scope and essence of this disclosure are given by the following claims.

Claims

1. A method for protecting membership in secure multi-party computing and communications, To provide a first dataset including a first identification information field and a second identification information field, This involves generating a padding dataset whose size is determined based on data privacy settings, Upsampling the first dataset using the padding dataset, Converting the first dataset described above, Dispatching the first dataset, Receiving a second dataset having a third identification information field and a fourth identification information field, For each piece of identification information in the first identification information field that matches the identification information in the third identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, and For each identification information in the second identification information field that matches the identification information in the fourth identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, The process involves generating a third dataset by performing an intersection operation based on the first dataset and the second dataset, A method that includes this.

2. The padding dataset includes a fifth identification information field and a sixth identification information field, Upsampling the first dataset using the padding dataset is: Upsampling the first identification information field using the elements in the fifth identification information field, The process includes inserting the random elements of the first set into the second identification information field. The method according to claim 1.

3. Upsampling the first dataset using the padding dataset is: Upsampling the second identification information field using the elements in the sixth identification information field, The further includes inserting a second set of random elements into the first identification information field. The method according to claim 2.

4. Before upsampling the first dataset using the padding dataset, shuffling the padding dataset, The method according to claim 1, further comprising:

5. The intersection of the padding dataset and the first dataset is empty. The method according to claim 1.

6. The first identification information field has a higher priority than the second identification information field. The third identification information field has a higher priority than the fourth identification information field. The method according to claim 1.

7. The aforementioned data privacy setting includes a first parameter and a second parameter, The size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter. The method according to claim 1.

8. The size of the padding dataset is determined based on the number of identification information fields in the first dataset. The method according to claim 7.

9. The size of the padding dataset is further determined based on the number of intersection operations. The method according to claim 8.

10. The first dataset includes a seventh identification information field, and the second dataset includes an eighth identification information field. Performing the intersection operation based on the first dataset and the second dataset to generate the third dataset is: For each identification information in the seventh identification information field that matches the identification information in the eighth identification information field, the row having the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset. The method according to claim 1.

11. A secure multi-party computing and communication system, Memory for storing the first dataset, It is a processor, The present invention provides a first dataset including a first identification information field and a second identification information field, Generate a padding dataset whose size is determined based on data privacy settings. The first dataset is upsampled using the padding dataset. The first dataset described above is transformed, The first dataset is dispatched, A second dataset having a third identification information field and a fourth identification information field is received. For each piece of identification information in the first identification information field that matches the identification information in the third identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, and For each identification information in the second identification information field that matches the identification information in the fourth identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, The third dataset is generated by performing an intersection operation based on the first dataset and the second dataset. Processor and A system equipped with these features.

12. The padding dataset includes a fifth identification information field and a sixth identification information field, and the processor further: The first identification information field is upsampled using the elements in the fifth identification information field. The random elements of the first set are inserted into the second identification information field. The system according to claim 11.

13. The aforementioned processor further, The second identification information field is upsampled using the elements in the sixth identification information field. The second set of random elements is inserted into the first identification information field. The system according to claim 12.

14. The aforementioned processor further, Before upsampling the first dataset using the padding dataset, the padding dataset is shuffled. The system according to claim 11.

15. The aforementioned data privacy setting includes a first parameter and a second parameter, The size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter. The system according to claim 11.

16. A non-temporary computer-readable medium in which computer-executable instructions are stored, wherein when the instructions are executed, one or more processors are configured to: To provide a first dataset including a first identification information field and a second identification information field, This involves generating a padding dataset whose size is determined based on data privacy settings, Upsampling the first dataset using the padding dataset, Converting the first dataset described above, Dispatching the first dataset, Receiving a second dataset having a third identification information field and a fourth identification information field, For each piece of identification information in the first identification information field that matches the identification information in the third identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, and For each identification information in the second identification information field that matches the identification information in the fourth identification information field, the row containing the matched identification information is deleted from the second dataset, and the deleted row is added to the third dataset, The process involves generating a third dataset by performing an intersection operation based on the first dataset and the second dataset, A computer-readable medium that allows the execution of operations including [specific actions].

17. The padding dataset includes a fifth identification information field and a sixth identification information field, Upsampling the first dataset using the padding dataset is: Upsampling the first identification information field using the elements in the fifth identification information field, The process includes inserting the random elements of the first set into the second identification information field. The computer-readable medium according to claim 16.

18. Upsampling the first dataset using the padding dataset is: Upsampling the second identification information field using the elements in the sixth identification information field, The further includes inserting a second set of random elements into the first identification information field. The computer-readable medium according to claim 17.

19. The aforementioned operation is, The further step includes shuffling the padding dataset before upsampling the first dataset using the padding dataset. The computer-readable medium according to claim 16.

20. The aforementioned data privacy setting includes a first parameter and a second parameter, The size of the padding dataset is determined such that the intersection operation is differentially confidential based on the first parameter and the second parameter. The computer-readable medium according to claim 16.

Images