Method and apparatus for processing privacy data

Abstract

The present specification provides a processing method and device of private data, the method comprises the following steps: encrypting a private data set of a first computing center to obtain first encrypted data; sending the first encrypted data to a second computing center; and making the second computing center perform intersection processing on the first encrypted data and second encrypted data obtained by encryption to obtain an intersection result. In the process of sensitive data interaction, the intersection processing after data encryption avoids the leakage of non-intersection data, reduces the risk of leakage of user private data, and protects data security.

Description

Technical Field

[0001] This disclosure relates to the field of data security technology, specifically to a method and apparatus for processing privacy data. Background Technology

[0002] Protecting user privacy data is a crucial part of ensuring data security. As the owner of user data, the client inevitably needs to upload user data to the server for calculation in some scenarios. During this process, sensitive data will be directly exposed to the server, causing a significant risk of privacy leakage. Summary of the Invention

[0003] To improve the security of privacy data interaction, this specification provides a method, apparatus, electronic device, storage medium, and computer program product for processing privacy data.

[0004] Firstly, embodiments of this specification provide a method for processing privacy data, the method comprising:

[0005] Obtain the first dataset, which is a private dataset of the first computing center;

[0006] The first dataset is encrypted to obtain the first encrypted data;

[0007] The first encrypted data is sent to the second computing center so that the second computing center can obtain the intersection result by intersecting the second encrypted data and the first encrypted data. The second encrypted data is data obtained by encrypting the second dataset, which is the private dataset of the second computing center.

[0008] In some implementations, the first computing center has the target application installed, and the second computing center includes the server-side of the target application; encrypting the first dataset to obtain the first encrypted data includes:

[0009] In response to detecting a request instruction from the target application to read the first dataset, the first dataset is encrypted to obtain first encrypted data;

[0010] Sending the first encrypted data to the second computing center includes sending the first encrypted data to the server of the target application.

[0011] In some implementations, the step of encrypting the first dataset to obtain first encrypted data in response to detecting a request instruction from the target application to read the first dataset includes:

[0012] In response to a detected request from the target application to read the first dataset, an authorization interface is displayed in the first computing center, the authorization interface including encrypted authorization options and unencrypted authorization options;

[0013] In response to detecting a triggered operation for the encryption authorization option, the first dataset is encrypted to obtain first encrypted data.

[0014] In some implementations, the first dataset includes one or more of the following:

[0015] Contacts, installed apps list, call logs, media files, calendar, location history.

[0016] In some embodiments, the privacy data processing method of this specification further includes:

[0017] Obtain the device identifier of the first computing center;

[0018] The device identifier is sent to the second computing center so that the second computing center generates a first key corresponding to the first computing center based on the pre-stored root key and the device identifier, and encrypts the second dataset based on the first key to obtain the second encrypted data.

[0019] In some implementations, sending the first encrypted data to the second computing center, so that the second computing center obtains an intersection result based on the intersection of the second encrypted data and the first encrypted data, includes:

[0020] The first encrypted data is divided into fragment identifiers;

[0021] The first encrypted data and the fragment identifier are sent to the second computing center so that the second computing center can perform intersection calculation on the first encrypted data according to the data fragments corresponding to the fragment identifier to obtain the intersection result, wherein the data fragments are obtained by the second computing center by dividing the second encrypted data.

[0022] In some implementations, the first computing center includes a server, and the second computing center includes a client; the step of sending the first encrypted data to the second computing center, so that the second computing center obtains an intersection result based on the intersection of the second encrypted data and the first encrypted data, includes:

[0023] The first encrypted data is divided into multiple data fragments;

[0024] Receive a fragment identifier sent by the second computing center, wherein the fragment identifier is obtained by the second computing center from dividing the second encrypted data;

[0025] The data fragment corresponding to the fragment identifier is sent to the second computing center so that the second computing center can obtain the intersection result by intersecting the data fragment and the first encrypted data.

[0026] Secondly, embodiments of this specification provide a method for processing privacy data, the method comprising:

[0027] Receive first encrypted data sent by the first computing center, wherein the first encrypted data is data obtained by encrypting the first dataset, and the first dataset is the private dataset of the first computing center;

[0028] The second dataset is encrypted to obtain the second encrypted data, which is a private dataset of the second computing center.

[0029] The intersection result is obtained by finding the intersection of the second encrypted data and the first encrypted data.

[0030] In some implementations, encrypting the second dataset to obtain the second encrypted data includes:

[0031] Receive the client identifier sent by the first computing center;

[0032] Based on the pre-stored root key and the client identifier, a first key corresponding to the first computing center is generated;

[0033] The second dataset is encrypted using the first key to obtain the second encrypted data.

[0034] In some embodiments, the method described herein further includes:

[0035] The second encrypted data is divided into multiple data fragments;

[0036] Receive a fragmentation identifier sent by the first computing center, wherein the fragmentation identifier is obtained by the first computing center by dividing the first encrypted data;

[0037] The step of obtaining the intersection result based on the second encrypted data and the first encrypted data includes:

[0038] The intersection result is obtained by performing an intersection calculation on the first encrypted data based on the fragment data corresponding to the fragment identifier.

[0039] In some embodiments, the first computing center includes a server, and the second computing center includes a client. The method described in this specification further includes:

[0040] The second encrypted data is divided into fragment identifiers.

[0041] The fragment identifier is sent to the first computing center so that the first computing center returns the corresponding data fragment based on the fragment identifier. The data fragment is obtained by the first computing center by dividing the first encrypted data.

[0042] Receive the data fragments sent by the first computing center that correspond to the fragment identifier;

[0043] The step of obtaining the intersection result based on the second encrypted data and the first encrypted data includes:

[0044] The intersection result is obtained by performing intersection calculations on the first encrypted data according to the data fragments corresponding to the fragment identifiers.

[0045] Thirdly, embodiments of this specification provide a privacy data processing apparatus, the apparatus comprising:

[0046] The data acquisition module is configured to acquire a first dataset, which is a private dataset of the first computing center.

[0047] The first encryption module is configured to encrypt the first dataset to obtain the first encrypted data;

[0048] The data sending module is configured to send the first encrypted data to the second computing center, so that the second computing center can obtain an intersection result based on the intersection of the second encrypted data and the first encrypted data, wherein the second encrypted data is data obtained by encrypting the second dataset, and the second dataset is a private dataset of the second computing center.

[0049] Fourthly, embodiments of this specification provide a privacy data processing apparatus, the apparatus comprising:

[0050] The data receiving module is configured to receive first encrypted data sent by the first computing center, wherein the first encrypted data is data obtained by encrypting a first dataset, and the first dataset is a private dataset of the first computing center.

[0051] The second encryption module is configured to encrypt the second dataset to obtain the second encrypted data, which is the private dataset of the second computing center.

[0052] The data intersection module is configured to obtain the intersection result by intersecting the second encrypted data and the first encrypted data.

[0053] Fifthly, embodiments of this specification provide an electronic device, including:

[0054] processor; and

[0055] The memory stores computer instructions that cause the processor to perform the method described in any of the above embodiments.

[0056] Sixthly, embodiments of this specification provide a computer program product for implementing the methods described in any of the above embodiments.

[0057] The processing method described in this specification includes encrypting a private dataset of a first computing center to obtain first encrypted data, sending the first encrypted data to a second computing center, and then having the second computing center perform an intersection calculation on the second encrypted data and the first encrypted data to obtain an intersection result. In the process of sensitive data interaction, the method of intersecting after data encryption avoids the leakage of non-intersecting data, reduces the risk of leakage of user privacy data, and protects data security. Attached Figure Description

[0058] To more clearly illustrate the technical solutions in the specific embodiments of this disclosure or the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0059] Figure 1 This is a system architecture diagram upon which the privacy data processing methods described in this manual rely.

[0060] Figure 2 This is a system architecture diagram on which the privacy data processing method in an exemplary implementation depends.

[0061] Figure 3 This is a flowchart of a method for processing privacy data in some embodiments of this specification.

[0062] Figure 4 This is an interactive flowchart of the privacy data processing methods in some embodiments of this specification.

[0063] Figure 5 This is a schematic diagram of the licensed interface of an exemplary implementation.

[0064] Figure 6 This is a schematic diagram of a privacy data processing method in an exemplary embodiment.

[0065] Figure 7 This is a flowchart of a method for processing privacy data in some embodiments of this specification.

[0066] Figure 8 This is a flowchart of a method for processing privacy data in some embodiments of this specification.

[0067] Figure 9 This is a schematic diagram of a privacy data processing method in an exemplary embodiment.

[0068] Figure 10 This is a flowchart of a method for processing privacy data in some embodiments of this specification.

[0069] Figure 11 This is a structural block diagram of a privacy data processing apparatus in some embodiments of this specification.

[0070] Figure 12 This is a structural block diagram of a privacy data processing apparatus in some embodiments of this specification.

[0071] Figure 13 These are structural block diagrams of electronic devices in some embodiments of this specification. Detailed Implementation

[0072] The technical solutions of this disclosure will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this disclosure, not all of them. All other embodiments obtained by those skilled in the art based on the embodiments of this disclosure without inventive effort are within the scope of protection of this disclosure. Furthermore, the technical features involved in the different embodiments of this disclosure described below can be combined with each other as long as they do not conflict with each other.

[0073] The user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this manual are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation portals are provided for users to choose to authorize or refuse.

[0074] Currently, when users use applications (Apps) on mobile devices, they often need to grant the applications various sensitive permissions in order to obtain a full functional experience. This process is often accompanied by the risk of privacy leaks.

[0075] For example, consider in-app friend recommendations. To implement friend recommendations, the app needs to request access to the user's contacts. Once the user grants this permission, the app uploads the user's contact data to the server. The server then performs an intersection calculation between the user's contact data and its own stored dataset of registered users, returning the result to the client. The user can then see which of their contacts have also registered with the app, thus enabling contact-based friend recommendations. During this process, the user's contact data is completely exposed to the server, posing a significant risk of privacy breaches.

[0076] Based on this, the embodiments of this specification provide a method, apparatus, electronic device, storage medium, and computer program product for processing privacy data, which aim to achieve intersection calculation of user data without exposing user privacy data and ensure data security.

[0077] Figure 1 A schematic diagram of the system architecture upon which the methods in this specification depend is shown. See [link / reference] Figure 1 As shown, the system illustrated in this specification includes a first computing center 410 and a second computing center 420, which are connected in a communicable manner via a network.

[0078] The first computing center 410 and the second computing center 420 refer to facilities / equipment with data storage, computing, and transmission / reception capabilities. The network can be wireless or wired, and the first computing center 410 and the second computing center 420 can exchange data through the network.

[0079] In this embodiment of the specification, the first computing center 410 holds a first dataset, which is a private dataset of the first computing center 410, meaning that the first dataset cannot be exposed to data participants outside the first computing center 410. The second computing center 420 holds a second dataset, which is a private dataset of the second computing center 420, meaning that the second dataset cannot be exposed to data participants outside the second computing center 420.

[0080] In the embodiments described in this specification, the equipment types of the first computing center 410 and the second computing center 420 are not specifically limited, and appropriate facilities / equipment can be selected according to different application scenarios.

[0081] For example, in one scenario, the first computing center 410 could be a client, such as a mobile phone, tablet, wearable device, or personal computer. The second computing center 420 could be a server, such as a cloud platform, server, or server cluster.

[0082] In another example, the first computing center 410 can be a server, such as a cloud platform, server, or server cluster. The second computing center 420 can be a client, such as a mobile phone, tablet, wearable device, or personal computer.

[0083] In another example, the first computing center 410 and the second computing center 420 can both be clients, such as mobile phones, tablets, wearable devices, personal computers, etc.

[0084] For example, in another example, both the first computing center 410 and the second computing center 420 can be servers, such as cloud platforms, servers, server clusters, etc.

[0085] In summary, in the embodiments described in this specification, the first computing center 410 and the second computing center 420 can be understood as two data participants that hold their own privacy datasets and have certain data processing and interaction capabilities. The specific device types of the two can be selected according to the needs of the scenario.

[0086] Figure 2 A schematic diagram of the system structure in an exemplary embodiment of this specification is shown, such as... Figure 2 As shown, the system architecture includes a server 11, a network 12, and several clients, such as PC (Personal Computer) 13 and mobile phone 14.

[0087] PC13 and mobile phone 14 refer to some types of clients that users can use. In fact, users can obviously also use clients such as tablet devices, laptops, PDAs (Personal Digital Assistants), wearable devices (such as smart glasses, smartwatches, etc.), etc., and one or more embodiments of this specification do not limit this.

[0088] During operation, one or more applications (Apps) can run on the client. Specifically, these client-side programs run on the client side of the Apps. These client-side programs can be native applications installed on the electronic device, or they can be mini-programs, quick apps, or other similar forms. Of course, when using web technologies such as HTML5 or similar technologies, the relevant functions can be implemented through a page displayed by a browser. Here, the browser can be a standalone browser application or a browser module embedded in some applications.

[0089] Server 11 can be a physical server containing an independent host, or server 11 can be a virtual server hosted by a host cluster. During operation, server 11 can run the server-side program of the aforementioned App to implement the App's server.

[0090] As for the network 12 that facilitates interaction between clients such as PC13 and mobile phones 14 and server 11, communication can be achieved using either wired or wireless networks, depending on the communication methods supported by the respective electronic devices. This manual does not impose any restrictions on this. For example, PC13 can support both wired and wireless communication, so it can use either wired or wireless networks as needed. Mobile phones 14 typically only support wireless communication, so they can use wireless networks for communication.

[0091] In some implementations, the first computing center is exemplified by a client (such as PC 13 or mobile phone 14), and the second computing center is exemplified by a server 11.

[0092] The client holds a first dataset, which is the client's private dataset; that is, the client does not want the first dataset to be exposed to other devices during data interaction. In the embodiments described in this specification, the first dataset includes, but is not limited to, the following datasets:

[0093] Contacts: refers to the collection of other users' mobile phone numbers saved on the client's database;

[0094] Installed Apps List: This refers to the collection used to record all applications (Apps) installed on the client;

[0095] Call logs: refer to the collection used to record the client's historical call information;

[0096] Media files: refer to collections of data such as music, documents, and videos stored on the client side;

[0097] A schedule is a collection of data used to record user memos, daily schedules, etc.

[0098] Location record: refers to the data set used to record the location trajectory of the client.

[0099] It is understood that the data sets described above involve sensitive data, that is, data directly related to user privacy. If this data is directly exposed to other devices, it can easily lead to the leakage of user privacy data. In the embodiments of this specification, these datasets are defined as the first dataset, that is, the client's private dataset.

[0100] The server holds a second dataset, which is its private dataset. This means the server does not want this second dataset to be exposed to other devices during data exchange. The server's second dataset includes, but is not limited to, whitelists or blacklists, and lists of registered users.

[0101] To facilitate understanding and explanation, the following example of an in-app friend recommendation scenario will be used to illustrate the privacy data processing method in the implementation of this manual.

[0102] Scenario 1 Description:

[0103] The target application is installed on the client and requests access to the client's address book. After obtaining user authorization, the target application sends the address book data to the server. The server calculates the intersection between the address book and its own list of registered users and returns the intersection result to the client. The target application on the client can then recommend users from the intersection to the client user.

[0104] In this example scenario, the client is the first computing center, and the client's address book is the first dataset. The server is the second computing center, and the server's list of registered users is the second dataset. The intersection result indicates which of the client user's address book friends have also registered for the target application.

[0105] Figure 3 This specification illustrates flowcharts of privacy data processing methods according to some embodiments. Figure 3 In the example, this method can be applied to the first computing center (i.e., the client), and the processing is performed by the first computing center.

[0106] like Figure 3 As shown, in some embodiments, the privacy data processing methods exemplified in this specification include:

[0107] S310. Obtain the first dataset.

[0108] As mentioned earlier, the client (i.e., the first computing center) holds the first dataset, which includes, but is not limited to, the following: contacts, a list of installed applications, call logs, media files, calendars, location records, etc. The first dataset is the client's private dataset, meaning that the client cannot directly expose the first dataset to other devices during data interaction.

[0109] In some implementations, taking a mobile phone as an example, the target application installed on the phone requests permissions for sensitive data from the client. Therefore, the client can execute the privacy data processing method described in this specification when the target application requests permissions for the first dataset and the user chooses to grant the permissions, thereby ensuring the security of the first dataset. The process of the client authorizing the target application is described in the following embodiments.

[0110] S320. Encrypt the first dataset to obtain the first encrypted data.

[0111] In the embodiments described in this specification, after obtaining the first dataset, the client cannot directly send the plaintext first dataset to the server (i.e., the second computing center). Instead, it needs to encrypt the first dataset to obtain encrypted first data. That is, before data interaction, the client encrypts the plaintext first dataset into ciphertext first encrypted data to protect the security of user privacy data.

[0112] For example, in the previous example, the first dataset is an address book. The client encrypts the address book, and the first encrypted data is the ciphertext data of the address book.

[0113] The algorithm process for encrypting the first dataset in the embodiments described in this specification will be explained in the following embodiments and will not be detailed here.

[0114] S330. Send the first encrypted data to the second computing center so that the second computing center can obtain the intersection result based on the intersection of the second encrypted data and the first encrypted data.

[0115] In the embodiments described in this specification, after the client obtains the first encrypted data, it can send the first encrypted data to the second computing center (i.e., the server).

[0116] For example, in the scenario described above, the client can encrypt the contact data at the system level to obtain the first encrypted data, and then the target application installed on the client can send the first encrypted data to the server.

[0117] In the embodiments described in this specification, the server needs to perform intersection processing on its own second dataset and the client's first dataset without exposing the data privacy of either party. The server can employ a privacy computation algorithm based on PSI (Private Set Intersection) technology. PSI can calculate the intersection of the two datasets without exposing other elements in the datasets. PSI is an algorithm based on ciphertext intersection; that is, if the ciphertexts of the two datasets intersect, then the plaintext data also intersects.

[0118] Therefore, server 11 can use the same encryption algorithm to encrypt the second dataset to obtain the second encrypted data. Then, it compares the second encrypted data with the obtained first encrypted data, filters out the overlapping parts, and the resulting intersection is the intersection of the first and second encrypted data.

[0119] It is worth noting that in the above implementation process, the target application can only obtain the ciphertext of the first dataset (i.e., the first encrypted data), and the server cannot decrypt the first encrypted data, thus eliminating the risk of data leakage during the interaction with the first dataset. Simultaneously, since the second dataset does not leave the server's local storage, there is also no risk of data leakage for the second dataset. The server performs data intersection calculation through privacy set computation, ensuring that the server only obtains the intersection portion of the first dataset. The server cannot obtain the non-intersection portions of the first dataset, guaranteeing the data security of the client's privacy data.

[0120] Figure 4 This specification illustrates interactive flowcharts of privacy data processing methods in some example scenarios. Figure 4 In the example, the first computing center is represented by the client, and the second computing center is represented by the server.

[0121] See Figure 4 As shown, the privacy data processing methods exemplified in this specification include:

[0122] S401: The client detects the target application's request to read the first dataset and displays the authorization interface.

[0123] The target application is the application (App) installed on the client. Generally speaking, when the client first opens the target application, the target application will request various permissions from the client, such as location permission, access to contacts permission, access to the photo album permission, access to media file permission, access to microphone permission, access to camera permission, etc.

[0124] When requesting permissions, one or more authorization interfaces will be displayed on the client. The authorization interface includes options such as "Allow only at runtime", "Always allow", and "Disallow", allowing users to choose whether to grant a certain permission to the target application according to their own needs.

[0125] "Allow only at runtime" means that the target application can only obtain this permission when the client is running the target application. For example, with location permission, if the user selects "Allow only at runtime", then the target application can only obtain location data when the client has the target application running. Once the target application is closed, it can no longer read location data.

[0126] "Always Allow" means that the target application can obtain this permission regardless of whether the client is running the target application. For example, with location permission, if the user selects "Always Allow," then the target application can obtain location data at any time, regardless of whether the target application is running.

[0127] "Disallow" means that the target application is not granted this permission. For example, with location permission, if the user selects "Disallow," the target application will not be able to obtain location data.

[0128] In related technical solutions, once a user chooses to grant authorization, it is equivalent to directly giving private data to the target application. For example, with contact permission, once a user chooses to grant authorization, the target application can read all the contact data of the client, which will be accompanied by a great risk of privacy leakage.

[0129] Therefore, in some embodiments of this specification, an "encryption authorization option" can be added to the authorization interface. For example... Figure 5 As shown, in addition to the "Allow only at runtime", "Always allow" and "Disallow" options mentioned above, the authorization interface also includes the "Authorize after data encryption" option.

[0130] exist Figure 5 In the example, "Allow only at runtime" and "Always allow" are defined as unencrypted authorization options. If the user selects these unencrypted authorization options, the target application can directly read the plaintext first dataset. "Authorize after data encryption" is defined as an encrypted authorization option. If the user selects this option, the client needs to encrypt the first dataset before sending it to the target application; that is, the target application can only obtain the encrypted data from the first dataset.

[0131] S402, User triggers encryption authorization option.

[0132] For example, if the first dataset uses a contact list, and the user doesn't want to grant plaintext contact list data to the target application, then they can, for example... Figure 5 On the authorization interface shown, select the encrypted authorization option; that is, the user clicks the "Authorize after data encryption" option on the authorization interface.

[0133] S403: The client detects a triggered operation for the encryption authorization option and encrypts the first dataset to obtain the first encrypted data.

[0134] In the embodiments described in this specification, when the client detects that the user has selected the encryption authorization option, it indicates that the user does not wish to grant the target application the plaintext first dataset. Therefore, the client can encrypt the first dataset to obtain the first ciphertext data.

[0135] Specifically, taking Android as an example of the client system, and the first dataset as an example of the address book, when the target application requests address book permissions from the user, the system can listen for user authorization operations at the application layer. If it detects the user selecting the encrypted authorization option, it can intercept the authorization operation at the application framework layer and call the address book data API (Application Programming Interface) to obtain the plaintext address book data. Then, it encrypts the address book data using a preset encryption algorithm to obtain the ciphertext address book data. Finally, it sends the ciphertext address book data to the target application at the application layer. In this example, the encrypted ciphertext address book data is the first encrypted data.

[0136] The algorithm process for encrypting the first dataset in the embodiments described in this specification will be explained in the following embodiments and will not be detailed here.

[0137] S404. Send the first encrypted data to the server of the target application.

[0138] In the embodiments described in this specification, after the target application of the client obtains the first encrypted data, it can send the first encrypted data to the server 11 of the target application through the network 12.

[0139] S405. The server encrypts the second dataset to obtain the second encrypted data.

[0140] S406. Obtain the intersection result by finding the intersection of the second encrypted data and the first encrypted data.

[0141] It is understandable that for server 11, the goal is to find the intersection of the first dataset and the second dataset. In this process, the non-intersecting parts of the first dataset in the client cannot be exposed to the server, and similarly, the non-intersecting parts of the second dataset in the server cannot be exposed to the client.

[0142] Therefore, the implementation method described in this specification can employ a privacy-preserving computation algorithm based on PSI (Private Set Intersection) technology. PSI can calculate the intersection of the two datasets without exposing other elements in the datasets. PSI is an algorithm based on ciphertext intersection; that is, if the ciphertexts of two datasets intersect, then the plaintext data also intersects.

[0143] Therefore, server 11 can use the same encryption algorithm to encrypt the second dataset to obtain the second encrypted data. Then, it compares the second encrypted data with the obtained first encrypted data, filters out the overlapping parts, and the resulting intersection is the intersection of the first and second encrypted data.

[0144] In the embodiments described in this specification, the intersection result obtained by the server 11 through privacy intersection is the intersection of the first encrypted data and the second encrypted data. Then, the server 11 decrypts the intersection part in the second encrypted data to obtain the plaintext data of the intersection data.

[0145] In the example provided, the plaintext data obtained by decrypting the intersection result is the intersection of the first and second datasets, representing which of the client user's contacts have also registered with the target application. Finally, the server 11 sends this intersection data to the client's target application, which can then display the intersection data and recommend contacts to the user.

[0146] It is worth noting that in the above implementation process, the target application can only obtain the ciphertext of the first dataset (i.e., the first encrypted data), and the server cannot decrypt the first encrypted data, thus eliminating the risk of data leakage during the interaction with the first dataset. Simultaneously, since the second dataset does not leave the server's local storage, there is also no risk of data leakage for the second dataset. The server performs data intersection calculation through privacy set computation, ensuring that the server only obtains the intersection portion of the first dataset. The server cannot obtain the non-intersection portions of the first dataset, guaranteeing the data security of the client's privacy data.

[0147] As can be seen from the above, in the embodiments of this specification, during the interaction of sensitive data, the method of encrypting the data and then finding the intersection avoids the leakage of non-intersection data, reduces the risk of leakage of user privacy data, and protects data security.

[0148] In Scenario 1 of the example above, the client's first dataset is illustrated using the address book as an example, and the server's second dataset is illustrated using the registered user list as an example. In fact, the implementation method in this specification is not limited to the above example scenario. For example...

[0149] Scenario 2: The client's first dataset is a "list of installed applications," and the server's second dataset is a "malware blacklist." The intersection result obtained using the method described above indicates that malware is installed on the client, posing a security risk. This scenario is applicable to risk detection and malware detection in financial apps.

[0150] Scenario 3: The client's first dataset is a "schedule," and the server's second dataset is "schedules of all registered users." The intersection result obtained through the method described above represents users with the same schedule as the client user. This scenario can be applied to user matching in travel apps, etc.

[0151] Scenario 4: The client's first dataset is "location records," and the server's second dataset is "location records of all registered users." The intersection result obtained through the method described above represents users with the same location as the client user. This scenario is applicable to matching users within the same city in dating apps.

[0152] Of course, besides the example scenarios mentioned above, the methods described in this manual can be applied to many other scenarios, which cannot be exhaustively listed here. Furthermore, in any of the example scenarios above, all data acquisition was done with the user's full authorization, and the user was informed of all risks in advance, and for example, [details omitted]. Figure 5 The example authorization interface allows users to choose to authorize or deny authorization.

[0153] Figure 6 A simplified flowchart of the privacy intersection algorithm in some embodiments of this specification is shown. See also: Figure 6 As shown, the first computing center holds the first dataset X = {x1, x2, ..., xN}, and the second computing center holds the second dataset Y = {y1, y2, ..., yM}.

[0154] The privacy set intersection algorithm mainly consists of a key negotiation phase and an online computation phase. In the key negotiation phase, the first and second computing centers need to negotiate the basic parameters used for the encryption computation. These basic parameters include p, q, and g, where p is a large prime number, q is a prime factor of p-1, and g represents the generator. Then, the first and second computing centers perform multiple OT (Oblivious Transfer) protocol interactions based on the negotiated basic parameters to generate their respective intermediate keys.

[0155] The OT protocol is a cryptographic protocol used to enable information exchange between a sender and a receiver in a privacy environment. In the embodiments described in this specification, based on a set of random numbers input by the first computing center, the OT protocol module generates an intermediate key *r* held by the first computing center and an intermediate key *R* held by the second computing center through multiple OT protocol interactions. The intermediate keys *r* and *R* are a pair of intermediate keys; that is, the intermediate keys *r* and *R* are only applicable to privacy computations between the first and second computing centers.

[0156] During the online computation phase, the first computing center can encrypt the first dataset X = {x1, x2, ..., xN} using an intermediate key r to obtain the first encrypted data E(X). Then, the first encrypted data E(X) is sent to the second computing center using the aforementioned method. The second computing center encrypts the second dataset Y = {y1, y2, ..., yM} using the intermediate key R to obtain the second encrypted data E(Y).

[0157] As described in the PSI algorithm principle, if the ciphertext data of two sets intersect, then the corresponding plaintext data also intersect. Therefore, the second computing center can compare the first encrypted data E(X) and the second encrypted data E(Y), and filter out the intersection portion to obtain the intersection result. Furthermore, the second computing center can obtain the plaintext intersection result by decrypting the ciphertext data of the intersection portion.

[0158] Finally, depending on the specific scenario, the second computing center may perform other operations based on the intersection result, or send the intersection result to the first computing center, which will then perform other operations based on the intersection result. This will be understood by those skilled in the art, and will not be elaborated upon in this specification.

[0159] In addition, in the above Figure 6 There are some aspects of the privacy intersection algorithm shown that are not fully described. Those skilled in the art can undoubtedly understand and fully implement it by referring to relevant technologies, and this specification will not elaborate further on these aspects.

[0160] In other embodiments of this disclosure, to reduce the key storage pressure on the server, a root key can be set on the server, so that the server key corresponding to each client can be derived from the root key. That is, the root key is the key used to generate the server key. The following describes... Figure 7 The implementation method is described below.

[0161] like Figure 7 As shown, in some implementations, the process of encrypting the second dataset by the second computing center includes:

[0162] S701, First Computing Center obtains device identification.

[0163] S702, The first computing center sends the device identifier to the second computing center.

[0164] S703, the second computing center generates the first key corresponding to the first computing center based on the pre-stored root key and device identifier.

[0165] S704. The second computing center encrypts the second dataset according to the first key to obtain the second encrypted data.

[0166] For example, in some implementations, combined with Figure 6 As shown in the example, the first computing center is represented by a client, and the second computing center by a server. During the key negotiation phase, it can be achieved through, for example... Figure 6 The OT protocol interaction process described in the implementation method generates a client intermediate key r and a server first key R, respectively.

[0167] The client (i.e., the first computing center) can store the intermediate key r in its own memory. Since the client only needs to store its own intermediate key r, the storage pressure is very small. However, for the server (i.e., the second computing center), in this embodiment of the specification, the server does not need to store the first key R; it only needs to pre-store a root key on the server.

[0168] During the online computing phase, the client (i.e., the first computing center) can refer to the aforementioned... Figure 6 The method of the implementation involves encrypting a first dataset X to obtain first encrypted data E(X), and then sending the first encrypted data E(X) to the server.

[0169] Meanwhile, since the server (i.e., the second computing center) does not store the first key R corresponding to this client, in order to ensure that the server can obtain the first key R corresponding to this client, the client can send its device identifier to the server along with the first encrypted data E(X).

[0170] Device identifiers are identification information used to uniquely identify a client, such as device UID (User Identification) and device IMEI (International Mobile Equipment Identification).

[0171] The client reads its own device identifier and sends it to the server. Upon receiving the client's device identifier, the server can use the pre-stored root key and the device identifier to generate a first key R that matches the client. For example, a one-way function algorithm can be used to derive the first key R based on the root key and device identifier. One-way functions include, but are not limited to, MD5, SHA, and MAC.

[0172] In the embodiments described in this specification, after generating the first key R, the server can combine it with the aforementioned... Figure 6 The implementation process involves encrypting the second dataset Y held by the entity using the first key R to obtain the second encrypted data E(Y). Then, data intersection calculation is performed to obtain the intersection result. Those skilled in the art can refer to the foregoing, and will not elaborate further.

[0173] As can be seen from the above, in the embodiments of this specification, by setting a root key on the server side and using the root key to derive the first key corresponding to each client during the privacy calculation process, there is no need to store the key data of each client on the server side, which greatly reduces the storage pressure on the server side and improves the calculation efficiency.

[0174] Continue to refer to Figure 6 As shown, in some scenarios, the data volume of the second data set Y of the second computing center is often very large. When the second computing center performs the intersection calculation, it needs to read and calculate the data of the entire second data set Y, which places high requirements on the load of the read / write and calculation resources of the server side.

[0175] Taking the friend recommendation scenario in the aforementioned target application as an example, the server needs to perform an intersection process on the address book data of the client and the entire registered user list. For some popular applications, the data volume of the registered user list they own can reach tens of millions or even hundreds of millions. Such a high-load reading and calculation of data results in a slow intersection calculation efficiency and cannot respond to user needs in a timely manner.

[0176] Based on this, in some embodiments of this specification, the data set can be sliced on the side with a larger data volume, so as to reduce the amount of operation data during the intersection process. The following will be described in combination with Figure 8 embodiments.

[0177] Such as Figure 8 As shown, in some embodiments, the privacy data processing method exemplified in this specification includes:

[0178] S801. The second computing center divides the second encrypted data to obtain multiple data slices.

[0179] In some embodiments, taking the client as an example for the first computing center, it holds the first data set X = {x1, x2,..., xN}, and taking the server as an example for the second computing center, it holds the second data set Y = {y1, y2,..., yM}, and N << M, that is, the data volume of the first data set X is much smaller than the data volume of the second data set Y.

[0180] In this example, after the second computing center encrypts the second data set through the steps of any of the foregoing embodiments to obtain the second encrypted data E(Y), it can perform data division on the second encrypted data E(Y). The purpose of data division is to divide the data set containing a large amount of data into multiple data slices. Each data slice can be understood as a data group, so that through this data division, the second encrypted data can be divided into multiple data groups.

[0181] In some implementations, a hash modulo algorithm can be used to partition the second encrypted data. Hash modulo refers to performing a hash function operation on the data and then performing a modulo operation on the resulting hash value. Based on the modulo result, the data is partitioned into the corresponding data group.

[0182] For example Figure 9 As shown, the second computing center can first encrypt the second dataset Y = {y1, y2, ..., yM} using the aforementioned method to obtain the second encrypted data E(Y). Then, by performing a hash modulo operation on each element of the second encrypted data E(Y), the element is divided into corresponding data fragments based on the calculation result. For example... Figure 9 The data fragments D1 to Dk in the second encrypted data E(Y) are divided into k data fragments on an average or approximately average basis.

[0183] S802. The first computing center divides the first encrypted data into data segments to obtain segment identifiers.

[0184] During the online computation phase, the first computing center encrypts the first dataset X = {x1, x2, ..., xN} using the aforementioned method to obtain the first encrypted data E(X). Before sending the first encrypted data E(X) to the second computing center, the first computing center can use the same data partitioning algorithm to partition the first encrypted data E(X).

[0185] For example, in one example, it can be used Figure 9 Using the same hash modulo algorithm, the first encrypted data E(X) is partitioned. The purpose of partitioning the first encrypted data is to obtain the fragment identifier corresponding to the first encrypted data E(X). In this example, the fragment identifier of a certain element in the first encrypted data E(X) is the value obtained after performing a hash modulo operation on that element.

[0186] It is understandable that for a certain element in the first encrypted data E(X), assuming that the hash modulo operation on that element yields a value of D1, then if that element also exists in the second encrypted data E(Y), the hash modulo operation on that element in the second encrypted data E(Y) will also yield a value of D1. That is, the element in the second encrypted data E(Y) will necessarily be assigned to "data shard D1" and will not appear in other data shards.

[0187] Based on this principle, it can be understood that the number of fragment identifiers obtained by partitioning the first encrypted data E(X) will never exceed the number of data fragments obtained by partitioning the second encrypted data E(Y). Especially when the amount of data in the first encrypted data E(X) is much smaller than that in the second encrypted data E(Y), the number of fragment identifiers obtained by partitioning the first encrypted data E(X) will also be much smaller than the number of data fragments obtained by partitioning the second encrypted data E(Y).

[0188] For example, see one example. Figure 9 As shown, the second encrypted data E(Y) is divided into k data fragments {D1, D2, D3, ..., Dk}. If the first encrypted data E(X) contains only one element, then after data partitioning, only one fragment identifier will be obtained, such as {D1}.

[0189] S803. Send the first dataset and shard identifier to the second computing center.

[0190] After obtaining the fragment identifier at the first computing center, the first encrypted data E(X) and the fragment identifier can be sent to the second computing center.

[0191] S804. The second computing center divides the data into fragments according to the fragment identifier and performs intersection processing on the first encrypted data to obtain the intersection result.

[0192] For example, in the previous example, the fragment identifier corresponding to the first encrypted data E(X) is {D1}, which means that the elements that can intersect with the first encrypted data E(X) can only be located in "data fragment D1". In another example, assuming the fragment identifier corresponding to the first encrypted data E(X) is {D1, D4, D6}, it means that the elements that can intersect with the first encrypted data E(X) can only be located in "data fragment D1", "data fragment D4", and "data fragment D6".

[0193] Therefore, after the second computing center obtains the fragment identifier sent by the first computing center, it can read and load only the corresponding data fragment based on the fragment identifier, without having to read and load other data fragments.

[0194] For example, in one instance, if the fragment identifier sent by the first computing center is {D1}, then the second computing center only needs to read and load the data within "data fragment D1". Data from data fragments D2 to Dk does not need to be read or loaded. In other words, the amount of data that would normally require reading and loading the entire second encrypted data only requires reading and loading 1 / k of the data in this embodiment, significantly reducing the overhead of data reading and loading.

[0195] After the second computing center reads and loads the data fragments corresponding to the fragment identifiers, it can use the data from these data fragments to perform intersection processing with the first encrypted data to obtain the corresponding intersection results, which will not be elaborated further in this specification. It is understandable that since the intersection calculation only requires performing intersection operations on a subset of data fragments, the computational load is greatly reduced, thus improving the efficiency of privacy-preserving computations.

[0196] In the above Figure 8 In this implementation, the first computing center is exemplified by a client, and the second computing center by a server. In this implementation, the client sends the first encrypted data to the server, which then performs the intersection processing. In other implementation scenarios, the server may need to send the second encrypted data to the client, which will then perform the intersection processing. The implementation method described in this specification is also applicable, and will be explained below.

[0197] For example, scenario 5:

[0198] Consumer electronic devices are generally subject to regional sales restrictions. Products sold across regions without authorization are considered illegal goods and are also known as "parallel imports." Parallel imports are products that are sold in contrast to officially authorized products.

[0199] Taking a mobile phone as an example, the mobile phone, as the client, holds its own machine code (such as UID, IMEI, etc.), while the official server holds a whitelist of authorized products. The client wants to check whether its own machine code is in the server's whitelist, that is, to check whether the product is a genuine product, but it does not want the query result to be exposed to the server.

[0200] In this scenario, if the client encrypts its machine code and sends it to the server, and the server performs a cross-communicating operation, the server can determine whether the client's product is genuine based on the cross-communicating result. To address this requirement, the following section combines... Figure 10 The implementation method is illustrated with a flowchart.

[0201] exist Figure 10 In the example, the first computing center is represented by a server, which holds a first dataset X = {x1, x2, ..., xN}. The second computing center is represented by a client, which holds a second dataset Y = {y1, y2, ..., yM}. See also Figure 10 As shown in the example, the privacy data processing method illustrated in this specification includes:

[0202] S1001, The server divides the first encrypted data into multiple data fragments.

[0203] In this example, the server (i.e., the first computing center) holds a first dataset X = {x1, x2, ..., xN}. The first dataset X is encrypted using any of the aforementioned implementation methods to obtain first encrypted data E(X). Then, the server partitions the first encrypted data E(X) into multiple data fragments. For the data partitioning process, please refer to the aforementioned... Figure 9 The implementation method is self-explanatory and will not be elaborated further.

[0204] For example, in one instance, the server divides the first encrypted data E(X) into k data fragments, D1 to Dk.

[0205] S1002, The client divides the second encrypted data to obtain fragment identifiers.

[0206] In this example, the client (i.e., the second computing center) first encrypts the second dataset Y = {y1, y2, ..., yM} according to the process of any of the aforementioned implementation methods to obtain the second encrypted data E(Y). Then, similar to S702 above, the client uses the same data partitioning algorithm to partition the second encrypted data E(Y) to obtain fragment identifiers. This process can be referred to in the aforementioned implementation methods and will not be repeated here.

[0207] For example, in Scenario 5, the second dataset contains only one element (i.e., the client's machine code), so the fragment identifier obtained after dividing the second encrypted data also contains only one element. For example, in one example, the fragment identifier corresponding to the second encrypted data is {D1}.

[0208] S1003, The client sends a fragment identifier to the server.

[0209] S1004. The server determines the corresponding data fragment based on the fragment identifier.

[0210] S1005. The server sends the data fragments corresponding to the fragment identifiers to the client.

[0211] In this example, the client sends the fragment identifier to the server. The server then selects the data fragment corresponding to the fragment identifier from all data fragments based on the received fragment identifier, and then sends these data fragments to the client.

[0212] For example, in the example above, the server receives the fragment identifier {D1} sent by the client, and can then determine that the corresponding data fragment is "data fragment D1". The server then only sends data fragment D1 to the client, and does not need to send the other data fragments.

[0213] S1006. The client performs intersection calculation on the second encrypted data E(Y) based on the received data fragments to obtain the intersection result.

[0214] In this example, after receiving the data fragment D1 sent by the server, the client can use the method described above to compare the data fragment D1 with the second encrypted data E(Y) to obtain the intersection result.

[0215] As can be understood, in this example scenario, since the intersection calculation is performed on the client side, only the client can know the intersection result, meaning only the client knows whether the device is a genuine product. The server, on the other hand, cannot obtain the client's machine code or know the intersection result, thus avoiding the risk of client privacy leakage.

[0216] In addition, in this embodiment, by using data fragmentation, the server only needs to send a portion of the data fragments to the client, without transmitting the entire second encrypted data. This greatly alleviates the pressure of data reading and transmission, reduces the pressure on client data storage, and improves the efficiency of privacy computing.

[0217] After actual measurement, Figure 10 In the implementation method, an 8-core, 16GB memory server is used. With a second dataset size of 1 data point on the client side and a first dataset size of 20,000 data points on the server side, the server request traffic can support 1000 QPS (queries per second), a significant improvement compared to the traditional 10 QPS. Furthermore, the response time for a single request is reduced from 2 seconds to less than 100ms, greatly improving data processing efficiency.

[0218] As described above, in the embodiments of this specification, during sensitive data interaction, the method of encrypting data and then finding its intersection avoids the leakage of non-intersection data, reduces the risk of user privacy data leakage, and protects data security. By setting a root key on the server side, the first key corresponding to each client is derived from the root key during privacy computation, thus eliminating the need to store the key data of each client on the server side, greatly reducing the storage pressure on the server side and improving computational efficiency. The data sharding process further reduces data communication and storage pressure, improving the efficiency of privacy computation.

[0219] In some embodiments, this specification provides a privacy data processing apparatus, such as... Figure 11 As shown, the device includes:

[0220] Data acquisition module 10 is configured to acquire a first dataset, which is a private dataset of the first computing center;

[0221] The first encryption module 20 is configured to encrypt the first dataset to obtain the first encrypted data;

[0222] The data sending module 30 is configured to send the first encrypted data to the second computing center so that the second computing center can obtain an intersection result based on the intersection of the second encrypted data and the first encrypted data. The second encrypted data is data obtained by encrypting the second dataset, which is a private dataset of the second computing center.

[0223] In some implementations, the first computing center has the target application installed, and the second computing center includes the server-side of the target application; the first encryption module 20 is configured to:

[0224] In response to detecting a request instruction from the target application to read the first dataset, the first dataset is encrypted to obtain first encrypted data;

[0225] Sending the first encrypted data to the second computing center includes sending the first encrypted data to the server of the target application.

[0226] In some implementations, the first encryption module 20 is configured to:

[0227] In response to a detected request from the target application to read the first dataset, an authorization interface is displayed in the first computing center, the authorization interface including encrypted authorization options and unencrypted authorization options;

[0228] In response to detecting a triggered operation for the encryption authorization option, the first dataset is encrypted to obtain first encrypted data.

[0229] In some implementations, the first dataset includes one or more of the following:

[0230] Contacts, installed apps list, call logs, media files, calendar, location history.

[0231] In some implementations, the data acquisition module 10 is configured to: acquire the device identifier of the first computing center;

[0232] The data sending module is configured to send the device identifier to the second computing center, so that the second computing center generates a first key corresponding to the first computing center based on the pre-stored root key and the device identifier, and encrypts the second dataset based on the first key to obtain the second encrypted data.

[0233] In some embodiments, the data sending module 30 is configured to:

[0234] The first encrypted data is divided into fragment identifiers;

[0235] The first encrypted data and the fragment identifier are sent to the second computing center so that the second computing center can perform intersection calculation on the first encrypted data according to the data fragments corresponding to the fragment identifier to obtain the intersection result, wherein the data fragments are obtained by the second computing center by dividing the second encrypted data.

[0236] In some implementations, the first computing center includes a server, and the second computing center includes a client; the data sending module 30 is configured to:

[0237] The first encrypted data is divided into multiple data fragments;

[0238] Receive a fragment identifier sent by the second computing center, wherein the fragment identifier is obtained by the second computing center from dividing the second encrypted data;

[0239] The data fragment corresponding to the fragment identifier is sent to the second computing center so that the second computing center can obtain the intersection result by intersecting the data fragment and the first encrypted data.

[0240] In some embodiments, this specification provides a privacy data processing apparatus, such as... Figure 12 As shown, the device includes:

[0241] The data receiving module 40 is configured to receive first encrypted data sent by the first computing center, wherein the first encrypted data is data obtained by encrypting a first dataset, and the first dataset is a private dataset of the first computing center.

[0242] The second encryption module 50 is configured to encrypt the second dataset to obtain the second encrypted data, wherein the second dataset is a private dataset of the second computing center.

[0243] The data intersection module 60 is configured to obtain an intersection result based on the intersection of the second encrypted data and the first encrypted data.

[0244] In some implementations, the second encryption module 50 is configured to:

[0245] Receive the client identifier sent by the first computing center;

[0246] Based on the pre-stored root key and the client identifier, a first key corresponding to the first computing center is generated;

[0247] The second dataset is encrypted using the first key to obtain the second encrypted data.

[0248] In some implementations, the data intersection module 60 is configured to:

[0249] The second encrypted data is divided into multiple data fragments;

[0250] Receive a fragmentation identifier sent by the first computing center, wherein the fragmentation identifier is obtained by the first computing center by dividing the first encrypted data;

[0251] The intersection result is obtained by performing an intersection calculation on the first encrypted data based on the fragment data corresponding to the fragment identifier.

[0252] In some implementations, the first computing center includes a server, the second computing center includes a client, and the data intersection module 60 is configured to:

[0253] The second encrypted data is divided into fragment identifiers.

[0254] The fragment identifier is sent to the first computing center so that the first computing center returns the corresponding data fragment based on the fragment identifier. The data fragment is obtained by the first computing center by dividing the first encrypted data.

[0255] Receive the data fragments sent by the first computing center that correspond to the fragment identifier;

[0256] The intersection result is obtained by performing intersection calculations on the first encrypted data according to the data fragments corresponding to the fragment identifiers.

[0257] In some embodiments, this specification provides an electronic device comprising:

[0258] processor; and

[0259] The memory stores computer instructions that cause the processor to perform the method described in any of the above embodiments.

[0260] In some embodiments, this specification provides a computer program product for implementing the methods described in any of the above embodiments.

[0261] Specifically, Figure 13 A schematic diagram of the structure of an electronic device 600 suitable for implementing the method of this disclosure is shown. Figure 13 The electronic device shown can perform the corresponding functions of the processor and storage medium described above.

[0262] like Figure 13As shown, the electronic device 600 includes a processor 601, which can perform various appropriate actions and processes according to a program stored in a memory 602 or a program loaded into the memory 602 from a storage section 608. The memory 602 also stores various programs and data required for the operation of the electronic device 600. The processor 601 and the memory 602 are connected to each other via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0263] The following components are connected to I / O interface 605: an input section 606 including a keyboard, mouse, etc.; an output section 607 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 608 including a hard disk, etc.; and a communication section 609 including a network interface card such as a LAN card, modem, etc. The communication section 609 performs communication processing via a network such as the Internet. A drive 610 is also connected to I / O interface 605 as needed. A removable medium 611, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on drive 610 as needed so that computer programs read from it can be installed into storage section 608 as needed.

[0264] In particular, according to embodiments of this disclosure, the above-described method process can be implemented as a computer software program. For example, embodiments of this disclosure include a computer program product comprising a computer program tangibly embodied on a machine-readable medium, the computer program containing program code for performing the above-described methods. In such embodiments, the computer program can be downloaded and installed from a network via communication section 609, and / or installed from removable medium 611.

[0265] Obviously, the above embodiments are merely examples for clear illustration and are not intended to limit the embodiments. Those skilled in the art will recognize that other variations or modifications can be made based on the above description. It is neither necessary nor possible to exhaustively list all embodiments here. However, obvious variations or modifications derived therefrom are still within the scope of protection of this disclosure.

Claims

1. A method for processing privacy data, characterized in that, The method includes: Obtain the first dataset, which is a private dataset of the first computing center; The first dataset is encrypted to obtain the first encrypted data; The first encrypted data is sent to the second computing center so that the second computing center can obtain the intersection result by intersecting the second encrypted data and the first encrypted data. The second encrypted data is data obtained by encrypting the second dataset, which is the private dataset of the second computing center.

2. The method according to claim 1, characterized in that, The first computing center has the target application installed, and the second computing center includes the server-side of the target application; encrypting the first dataset to obtain the first encrypted data includes: In response to detecting a request instruction from the target application to read the first dataset, the first dataset is encrypted to obtain first encrypted data; Sending the first encrypted data to the second computing center includes sending the first encrypted data to the server of the target application.

3. The method according to claim 2, characterized in that, The step of encrypting the first dataset to obtain first encrypted data in response to a detected request from the target application to read the first dataset includes: In response to a detected request from the target application to read the first dataset, an authorization interface is displayed in the first computing center, the authorization interface including encrypted authorization options and unencrypted authorization options; In response to detecting a triggered operation for the encryption authorization option, the first dataset is encrypted to obtain first encrypted data.

4. The method according to claim 1, characterized in that, The first dataset includes one or more of the following: Contacts, installed apps list, call logs, media files, calendar, location history.

5. The method according to any one of claims 1 to 4, characterized in that, Also includes: Obtain the device identifier of the first computing center; The device identifier is sent to the second computing center so that the second computing center generates a first key corresponding to the first computing center based on the pre-stored root key and the device identifier, and encrypts the second dataset based on the first key to obtain the second encrypted data.

6. The method according to any one of claims 1 to 4, characterized in that, The step of sending the first encrypted data to the second computing center, so that the second computing center can obtain the intersection result based on the intersection of the second encrypted data and the first encrypted data, includes: The first encrypted data is divided into fragment identifiers; The first encrypted data and the fragment identifier are sent to the second computing center so that the second computing center can perform intersection calculation on the first encrypted data according to the data fragments corresponding to the fragment identifier to obtain the intersection result, wherein the data fragments are obtained by the second computing center by dividing the second encrypted data.

7. The method according to claim 1, characterized in that, The first computing center includes a server, and the second computing center includes a client; the step of sending the first encrypted data to the second computing center, so that the second computing center obtains an intersection result based on the intersection of the second encrypted data and the first encrypted data, includes: The first encrypted data is divided into multiple data fragments; Receive a fragment identifier sent by the second computing center, wherein the fragment identifier is obtained by the second computing center from dividing the second encrypted data; The data fragment corresponding to the fragment identifier is sent to the second computing center so that the second computing center can obtain the intersection result by intersecting the data fragment and the first encrypted data.

8. A method for processing privacy data, characterized in that, The method includes: Receive first encrypted data sent by the first computing center, wherein the first encrypted data is data obtained by encrypting the first dataset, and the first dataset is the private dataset of the first computing center; The second dataset is encrypted to obtain the second encrypted data, which is a private dataset of the second computing center. The intersection result is obtained by finding the intersection of the second encrypted data and the first encrypted data.

9. The method according to claim 8, characterized in that, The process of encrypting the second dataset to obtain the second encrypted data includes: Receive the client identifier sent by the first computing center; Based on the pre-stored root key and the client identifier, a first key corresponding to the first computing center is generated; The second dataset is encrypted using the first key to obtain the second encrypted data.

10. The method according to claim 8, characterized in that, Also includes: The second encrypted data is divided into multiple data fragments; Receive a fragmentation identifier sent by the first computing center, wherein the fragmentation identifier is obtained by the first computing center by dividing the first encrypted data; The step of obtaining the intersection result based on the second encrypted data and the first encrypted data includes: The intersection result is obtained by performing an intersection calculation on the first encrypted data based on the fragment data corresponding to the fragment identifier.

11. The method according to claim 8, characterized in that, The first computing center includes a server, the second computing center includes a client, and the method further includes: The second encrypted data is divided into fragment identifiers. The fragment identifier is sent to the first computing center so that the first computing center returns the corresponding data fragment based on the fragment identifier. The data fragment is obtained by the first computing center by dividing the first encrypted data. Receive the data fragments sent by the first computing center that correspond to the fragment identifier; The step of obtaining the intersection result based on the second encrypted data and the first encrypted data includes: The intersection result is obtained by performing intersection calculations on the first encrypted data according to the data fragments corresponding to the fragment identifiers.

12. A device for processing privacy data, characterized in that, The device includes: The data acquisition module is configured to acquire a first dataset, which is a private dataset of the first computing center. The first encryption module is configured to encrypt the first dataset to obtain the first encrypted data; The data sending module is configured to send the first encrypted data to the second computing center, so that the second computing center can obtain an intersection result based on the intersection of the second encrypted data and the first encrypted data, wherein the second encrypted data is data obtained by encrypting the second dataset, and the second dataset is a private dataset of the second computing center.

13. A privacy data processing apparatus, characterized in that, The device includes: The data receiving module is configured to receive first encrypted data sent by the first computing center, wherein the first encrypted data is data obtained by encrypting a first dataset, and the first dataset is a private dataset of the first computing center. The second encryption module is configured to encrypt the second dataset to obtain the second encrypted data, which is a private dataset of the second computing center. The data intersection module is configured to obtain the intersection result by intersecting the second encrypted data and the first encrypted data.

14. An electronic device, characterized in that, include: processor; and A memory storing computer instructions for causing a processor to perform the method according to any one of claims 1 to 11.

15. A computer program product, characterized in that, The computer program product is used to implement the method according to any one of claims 1 to 11.

Images