A decentralized multi-server security aggregation system and method
By using a decentralized secure aggregation system, and leveraging bulletin boards and multiple servers to generate homomorphic chameleon hash public parameters and public key encryption, the problem of establishing a secure channel between the client and the server is solved. This enables secure and verifiable federated learning aggregation, simplifies the system architecture, and reduces the communication burden.
Patent Information
- Application Number
- CN202210817202.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2022-07-12
- Publication Date
- 2024-11-01
- Estimated Expiration
- 2042-07-12
AI Technical Summary
In existing federated learning, establishing secure channels between clients and multiple servers is expensive and difficult to achieve, and secure and verifiable aggregation is difficult to achieve without a trusted third party.
A decentralized secure aggregation system is adopted, using a bulletin board system as a data intermediary. Multiple servers jointly generate homomorphic chameleon hash public parameters and public key encryption, combined with additive homomorphic secret sharing and public key encryption, to achieve secure information transmission and aggregation between clients and servers.
It enables secure and verifiable federated learning aggregation without the need for trusted third parties and secure channels, simplifying the system architecture, reducing communication burden, and improving system security and efficiency.
Smart Images

Figure CN115378572B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of data privacy protection, and in particular to a secure aggregation method in federated learning. Background Art
[0002] Federated learning is a distributed machine learning framework that allows clients to upload model parameters to jointly train models instead of directly uploading private training data. This can protect the privacy of the client's original data to a certain extent, but studies have shown that attackers can still infer the original training data through the uploaded model gradients.
[0003] In order to protect the security of client private parameters, some studies have proposed secure aggregation protocols, that is, in federated learning, the server can obtain global model parameters without leaking the private parameters of a single client. In addition, in order to prevent the aggregation results from being maliciously tampered with, verifiable secure aggregation protocols are increasingly attracting attention. Among them, a secure aggregation system based on a trusted third party is one direction, but there may be some scenarios in reality where there is no trusted third party; another direction is multi-server secure aggregation based on a secure channel established between the client and each server, but in reality, most clients are mobile phones or IoT devices, and such secure channels between multiple servers are expensive and difficult to implement (client devices). Summary of the invention
[0004] In response to the above situation, the present disclosure provides a decentralized security aggregation system and method that does not require the establishment of a secure channel between a client and multiple servers. It can achieve secure and verifiable federated learning aggregation without a trusted third party and a secure channel between the client and the server.
[0005] The decentralized multi-server security aggregation system provided by the present disclosure includes: a client, a server, and a bulletin board system jointly maintained by the server, wherein:
[0006] The bulletin board is the data exchange intermediary for all participants. All data output by the participants are uploaded to the bulletin board, and the required data can be downloaded from the bulletin board;
[0007] The client is used to generate a homomorphic chameleon random number and calculate the homomorphic chameleon hash value of its own private input; and based on additive homomorphic secret sharing, it generates secret sharing shares of its own private input and homomorphic chameleon random number for different servers respectively, encrypts the two with the public key of the server to generate a ciphertext, and outputs the ciphertext and the homomorphic chameleon hash value;
[0008] The server is used to participate in the generation of homomorphic chameleon hash public parameters with other servers and distribute them to all participants; generate its own public-private key pair and make the public key public; decrypt the collected ciphertext, secretly aggregate the secret sharing shares of each client, and output the aggregated result;
[0009] The system is publicly verifiable, and any party can use the aggregation results published on the bulletin board and the homomorphic chameleon hash public parameters and homomorphic chameleon hash values to secretly reconstruct the aggregation results and verify the aggregation results based on the homomorphism of the chameleon hash function.
[0010] Furthermore, the system includes a cryptographic component running on the client, the server and the trusted third party, and the cryptographic component includes:
[0011] Public key encryption module, used to generate the server's public and private key pairs, encrypt messages sent by the client, and decrypt them on the server side;
[0012] Additive homomorphic secret sharing module, which is used to generate secret sharing shares of its own private input and homomorphic chameleon random numbers based on additive homomorphic secret sharing, and distribute them to the server; perform secret aggregation on the server side; and secretly reconstruct the aggregation results;
[0013] The homomorphic chameleon hash module is used to generate homomorphic chameleon hash public parameters and homomorphic chameleon hash values, and to verify the aggregation results based on the homomorphism of the chameleon hash function.
[0014] The present disclosure also provides a decentralized multi-server security aggregation method based on homomorphic chameleon hashing corresponding to the above system, comprising the following steps:
[0015] Public parameter generation: Multiple servers jointly generate public parameters of homomorphic chameleon hash and distribute them to all participants;
[0016] Key generation: The server generates its own public-private key pair and publishes the public key;
[0017] Input sharing generation: The client generates a homomorphic chameleon random number and calculates the homomorphic chameleon hash value of its own private input; based on additive homomorphic secret sharing, it generates secret sharing shares of its own private input and homomorphic chameleon random number for different servers respectively. The two use the server's public key to encrypt and generate ciphertext, and output the ciphertext and homomorphic chameleon hash value;
[0018] Aggregation: The server decrypts the received ciphertext, aggregates the secret sharing shares received from each client, and outputs the aggregation result;
[0019] Verification: Using the aggregation results published on the bulletin board and the homomorphic chameleon hash public parameters and homomorphic chameleon hash values, the aggregation results are secretly reconstructed, and the aggregation results are verified based on the homomorphism of the chameleon hash function;
[0020] The data output by all participants are output to the bulletin board, and the required data are downloaded from the bulletin board.
[0021] Furthermore, the public parameter generation adopts the zero-knowledge proof algorithm after the Fiat-Shamir transformation of the Sigma protocol for the classic discrete logarithm problem:
[0022] Given a common input (g, h, p), where p is a prime number and |p| = κ, g is A subgroup of order p The generator of h = g, and κ is the security parameter; the prover proves to the verifier that he knows α such that h = g α
[0023] Prove(g,h,α)→(a,z): The prover takes g,h and a private input α as input, where
[0024] (1) Provers are randomly selected And calculate a = g r ;
[0025] (2) For hash functions Calculate e = H(g, h, a);
[0026] (3) Calculate z = r + e·α;
[0027] (4) Output proof (a, z);
[0028] Verify(g,h,a,z)→0 / 1: The verifier takes g,h and proof(a,z) as input.
[0029] (1) Based on the above hash function H(·), calculate e=H(g,h,a);
[0030] (2) Verify equation g z =a·h e whether it is established;
[0031] (3) If the above equation holds, the proof is accepted and the output is 1; otherwise, the proof is rejected and the output is 0;
[0032] ServerS j Random Selection And calculate Using Prove(g,h j,α j )→(a j ,z j ), (h j ,a j ,z j )public;
[0033] ServerS j or client C i Both can run the zero-knowledge verification algorithm Verify(g,h j’ ,a j′ ,z j′ ), when all j′∈{1,2,…m} are verified, we get As the public parameter CHpp of homomorphic chameleon hash, j=1,…m, m is the number of multiple servers in the aggregation system.
[0034] Furthermore, the method also includes the step of packaging the client's private input parameters into a single large integer.
[0035] Furthermore, the RSA public key encryption algorithm is used for public-private key pair generation, public key encryption, and ciphertext decryption.
[0036] Furthermore, the additive homomorphic secret sharing adopts the Shamir secret sharing method to generate secret sharing shares, secret aggregation, and secret reconstruction of the aggregation results.
[0037] The homomorphic chameleon hash algorithm based on the discrete logarithm hypothesis is used to generate aggregate verification information and verify the aggregate results, including:
[0038] Public parameter generation: CH.Gen(1 κ )→(CHpp=(p,G,g,h),TD=α), where 1 κ is a security parameter; CHpp is a public parameter; TD is a trapdoor; g is a cyclic group of order p The generator of ; h is a group element, is the set of integers modulo p;
[0039] Hash value calculation: CH.Hash((p,G,g,h),x,r)→(ch=g x h r ), where ch is the hash value, x is the message to be hashed, r is a random number,
[0040] The hash algorithm also satisfies: for any given x and x′, for any r, r′=(xx′+αr) / α can be found to satisfy: CH.Hash(CHpp,x,r)=CH.Hash(CHpp,x′,r′); and:
[0041] CH.Hash(CHpp,x1+x2,r1+r2)=CH.Hash(CHpp,x1,r1)·CH.Hash(CHpp,x2,r2)
[0042] For the aggregation result, verify CH.Hash(CHpp,y,r)=Π i∈[1,n] ch i Is it true? y, r are the aggregation results, and n is the number of clients.
[0043] The decentralized multi-server secure aggregation system and method provided by the present disclosure generates public parameters through multiple servers, and transmits and obtains data through the bulletin board system, and then ensures the security and correctness of information transmission and aggregation between the client and multiple servers through additive homomorphic secret sharing and public key encryption. Therefore, the client and the server no longer rely on a trusted third party, and do not rely on a dedicated secure channel, and the system architecture is simpler and easier to implement; secondly, the aggregation verification is performed using homomorphic chameleon hashing to ensure the integrity of the aggregation. Compared with the currently commonly used verification schemes, this method reduces the group elements that need to be submitted for transmission and reduces the communication burden. In this way, a simple, secure, and efficient comprehensive optimization scheme for the multi-server aggregation system is achieved. BRIEF DESCRIPTION OF THE DRAWINGS
[0044] The above and other objects, features and advantages of the present disclosure will become more apparent through a more detailed description of exemplary embodiments of the present disclosure in conjunction with the accompanying drawings, wherein like reference numerals generally represent like components throughout the exemplary embodiments of the present disclosure.
[0045] Figure 1 Shows a schematic diagram of the structure of a security aggregation system embodiment according to the present disclosure;
[0046] Figure 2 A flow chart of an embodiment of a security aggregation method according to the present disclosure is shown. DETAILED DESCRIPTION
[0047] The preferred embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although the preferred embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided to make the present disclosure more thorough and complete, and to fully convey the scope of the present disclosure to those skilled in the art.
[0048] The present disclosure provides a security aggregation system mainly for multi-server federated learning scenarios.
[0049] Adversary model: Assuming that all clients execute the protocol honestly, the adversary can control up to t-1 (t is the secret sharing threshold) servers. It has two goals: 1) infer the private model parameters (such as gradients) of the honest clients; 2) make the honest clients accept a forged aggregation result.
[0050] Accordingly, secure aggregation must ensure the security of the private model parameters of honest clients to prevent them from being inferred by adversaries; ensure aggregation integrity, that is, prevent honest clients from accepting forged aggregation results. In addition, in the real world, clients participating in training may be disconnected due to poor network conditions or insufficient power, and we also hope to minimize the impact of such situations.
[0051] Specifically, taking the medical auxiliary diagnosis scenario as an example, as shown in the attached Figure 1 As shown, m hospitals / medical institutions S j (j=1,..m) and medical equipment C of n patients i (i=1,..n) for joint training, patient medical devices (clients), hospitals / medical institutions (servers) constitute a multi-server federated learning system. In order to prevent hospitals / medical institutions from colluding to tamper with the aggregated results of federated learning and to improve the efficiency of system interaction, the features of the secure aggregation system constructed in this embodiment are as follows:
[0052] (1) The system bulletin board is used as a bridge for data transmission, that is, the data output by all participants are uploaded to the bulletin board, and the required data are downloaded from the bulletin board.
[0053] The bulletin board is maintained by multiple servers, and all users (clients / servers) can upload or download all data on the bulletin board. In this embodiment, the client and the server output and obtain data through the bulletin board, and then ensure data security through means such as secret sharing and public key encryption, so that the client and the server no longer need to rely on the establishment of a secure channel.
[0054] (2) Multiple servers jointly generate homomorphic chameleon hash public parameters and distribute them to all participants.
[0055] (3) Client C i :Generate a homomorphic chameleon random number, calculate the homomorphic chameleon hash value of your own private input; and based on additive homomorphic secret sharing, generate secret sharing shares of your own private input and homomorphic chameleon random number for different servers respectively, and encrypt the two with the public key to generate ciphertext {ct i,j} j∈[1,m], output the ciphertext and the homomorphic chameleon hash value.
[0056] (4) Server S j : Generate your own public-private key pair and publish the public key; decrypt the collected ciphertexts of each client with your own private key; also based on additive homomorphic secret sharing, secretly aggregate the secret sharing shares of each client and output the aggregated result y j .
[0057] (5) The system is publicly verifiable. Any of the participants can use the aggregation results and homomorphic chameleon hash public parameters and homomorphic chameleon hash values posted on the bulletin board to secretly reconstruct the aggregation results, verify the aggregation results based on the homomorphism of the chameleon hash function, and output the verification results.
[0058] In this embodiment, the above security aggregation function of the system is completed by the cryptographic component running on the client and the server. The computing modules it contains include:
[0059] Public key encryption module (PKE.KGen, PKE.Enc, PKE.Dec), meeting IND-CPA security (i.e. indistinguishability from chosen plaintext attacks)
[0060] In order to implement client C i With server S j The public key encryption module is used for secure communication between client C i Will be sent to S j Message i,j , use S j The public key pk j Encryption is performed to obtain only the server S j The ciphertext ct that can be decrypted i,j ; After receiving the ciphertext, the server uses its private key sk j Decryption completed.
[0061] Specifically including sub-modules:
[0062] PKE.KGen(1 κ )→(sk,pk): with security parameter 1 κ As input, output a public and private key pair (sk, pk);
[0063] PKE.Enc(pk,m)→ct: takes public key pk and message m as input and generates ciphertext ct;
[0064] PKE.Dec(sk,ct)→m: Take the private key sk and the ciphertext message ct as input and decrypt the message m.
[0065] Additive homomorphic secret sharing modules (SS.Share, SS.Eval, SS.Recon)
[0066] In order to prevent the adversary from inferring the client's private model parameters or the aggregation results from being maliciously tampered with, this module is used to decompose the client's private parameters and verification information, generate secret sharing shares for different servers, perform secret aggregation on the server side, and secretly reconstruct the aggregation results. It specifically includes submodules:
[0067] Secret sharing shares are generated with secret value x i and threshold t and server set {S j} j∈[1,m] As input, for each server S j Generate secret shares , where j∈[1,m];
[0068] Based on the additive homomorphic property, given a series of shared j The secret share Output an additive aggregate share y j ;
[0069] SS.Recon(t,{y j} j∈Τ )→y: secret reconstruction, given a threshold t, and a series of aggregate shared values y j , where j satisfies When |Τ|≥t, the output Otherwise y=⊥.
[0070] Homomorphic Chameleon Hash Module
[0071] Used to generate aggregate verification information and verify the aggregated results. Preferably, in this embodiment, based on the existing Chameleon Hash algorithm, a simplified Chameleon Hash function (Chameleon-Hash) (CH.Gen, CH.Hash, CH.HashCheck, CH.Adapt) is defined, specifically including:
[0072] CH.Gen(1 κ )→(CHpp, TD): Take the security parameter as input and output the public parameter CHpp and the trapdoor TD;
[0073] CH.Hash(CHpp,x,r)→ch: takes public parameter CHpp, message x to be hashed and random number r as input, and outputs ch;
[0074] CH.HashCheck(CHpp,m,r,ch)→0 / 1: If the verification passes, output 1, if not, output 0;
[0075] CH.Adapt(TD,x,r,ch,x′)→r′: With trapdoor TD, hash value hash, original message x, original random number r and new message x′, a new random number r′ can be output so that CH.HashCheck(CHpp,x′,r′,hash)=1.
[0076] Compared with general hash functions, the chameleon hash function required in the present disclosure needs to satisfy the chameleon property in addition to the anti-collision property, that is, for any given x and x′, for any r, we can find:
[0077] r′←CH.Adapt(TD,x,r,hash,x′)
[0078] It satisfies CH.Hash(CHpp,x,r)=CH.Hash(CHpp,x′,r′).
[0079] That is, the chameleon hash function must meet the following requirements: correctness, computational indistinguishability of r (r is generated randomly or through CH.Adapt(·)), and collision resistance; in addition, it is also required to be homomorphic, that is,
[0080] CH.Hash(CHpp,x1+x2,r1+r2)=CH.Hash(CHpp,x1,r1)·CH.Hash(CHpp,x2,r2)
[0081] (6) As a preferred embodiment, the present embodiment adopts a non-interactive mode, that is, the client only needs to submit information once, thereby avoiding the impact of clients participating in the training being disconnected during the training.
[0082] Attached Figure 2 A flowchart of an exemplary embodiment of an aggregation method applicable to the above-mentioned multi-server security aggregation system is given. The following steps are included:
[0083] S101, public parameter generation:
[0084] The public parameter CHpp of the homomorphic chameleon hash is generated by multi-party secure computing that is resistant to malicious collusion.
[0085] Considering the possibility that servers may collude with each other, a method for generating the public parameters CHpp=(p, G, g, h) of homomorphic chameleon hash based on the discrete logarithm hypothesis is preferred:
[0086] The zero-knowledge proof algorithm is based on the Sigma protocol for the classic discrete logarithm problem after being transformed by Fiat-Shamir:
[0087] Given a common input (g, h, p), where p is a prime number and |p| = κ, g is A subgroup of order p The generator of h = g, and κ is the security parameter; the prover proves to the verifier that he knows α such that h = g α
[0088] Prove(g,h,α)→(a,z): The prover takes g,h and a private input α as input, where
[0089] (1) Provers are randomly selected And calculate a = g r ;
[0090] (2) For hash functions Calculate e = H(g, h, a);
[0091] (3) Calculate z = r + e·α;
[0092] (4) Output proof (a, z);
[0093] Verify(g,h,a,z)→0 / 1: The verifier takes g,h and proof(a,z) as input.
[0094] (1) Based on the above hash function H(·), calculate e=H(g,h,a);
[0095] (2) Verify equation g z =a·h e whether it is established;
[0096] (3) If the above equation holds, the proof is accepted and the output is 1; otherwise, the proof is rejected and the output is 0;
[0097] ServerS j Random Selection And calculate Using Prove(g,h j ,α j )→(a j ,z j ), (h j ,a j ,zj )public;
[0098] ServerS j or client C i Both can run the zero-knowledge verification algorithm Verify(g,h j′ ,a j′ ,z j′ ), when all j′∈{1,2,…m} are verified, we get As the public parameter CHpp of homomorphic chameleon hash, j=1,…m, m is the number of multiple servers in the aggregation system.
[0099] S102, key generation:
[0100] Given security parameter 1 κ , server S j Run the generation algorithm PKE.KGen(1 κ ), generate your own public and private key pair (pk j ,sk j ), and the public key pk j Make it public.
[0101] S103, input sharing generation:
[0102] Given the secret sharing algorithm threshold t, public parameter CHpp and server public key list {pk j} j∈[1,m] The client randomly selects a homomorphic chameleon random number, generates a private input secret sharing share and a homomorphic chameleon random number secret sharing share for different servers, calculates the homomorphic chameleon hash value of the private input, encrypts the two with the server's public key based on the additive homomorphic secret sharing algorithm to generate a ciphertext, and outputs the ciphertext and the homomorphic chameleon hash value.
[0103] The specific steps include:
[0104] (1) Use the additive homomorphic secret sharing algorithm to generate your own private input x i For each server j} j∈[1,m] The secret sharing share
[0105] (2) Randomly extract the chameleon random number r i , compute the private input x i The homomorphic chameleon hash value ch i ←CH.Hash(CHpp,x i ,r i );
[0106] (3) Generate a chameleon random number r using the additive homomorphic secret sharing algorithm i For each server j} j∈[1,m] The secret sharing share
[0107] (4) For j∈[1,m], use server S j The public key pk j , generate the corresponding ciphertext
[0108] (5) Output ciphertext {ct i,j} j∈[1,m] and Chameleon hash value ch i .
[0109] S104, polymerization
[0110] The server decrypts the ciphertext sent to itself with its own private key, and also uses the additive homomorphic secret sharing algorithm to aggregate and output the collected secret sharing shares of each client.
[0111] The specific steps include:
[0112] (1) Server S j According to your own private key sk j , for the collected client ciphertext {ct i,j} i∈[1,n] Decrypt it and get where i∈[1,n];
[0113] (2) Using the additive homomorphic secret sharing algorithm, the secret sharing aggregation value is calculated and
[0114] (3) Output (y j ,r j ).
[0115] S105, verification:
[0116] The aggregation result published on the bulletin board and the homomorphic chameleon hash public parameters and the homomorphic chameleon hash value are used to secretly reconstruct the aggregation result, and the aggregation result is verified based on the homomorphism of the chameleon hash function.
[0117] That is, according to the given public parameter CHpp, threshold t, the collected client chameleon hash value {ch i} i∈[1,n] , and the shared aggregate value output by the server and in And |Τ|≥t, the homomorphism of the chameleon hash function is used for verification, which specifically includes the following steps:
[0118] (1) Using the secret reconstruction algorithm of additive homomorphic secret sharing, we can recover y←SS.Recon(t,{y j} j∈Τ ) and r←SS.Recon(t,{r j} j∈Τ );
[0119] (2) Using the homomorphism of the Chameleon hash algorithm to verify the equation CH.Hash(CHpp,y,r)=Π i∈[1,n] ch i whether it is established;
[0120] (3) If the above equation holds, output y; otherwise, output ⊥.
[0121] Preferably, the public key encryption in this embodiment adopts the RSA public key encryption algorithm. In addition, DH / ECDSA / ECDH / SM2 algorithm, or other public key encryption algorithms that comply with IND-CPA security can also be considered.
[0122] Preferably, the additive homomorphic secret sharing in this embodiment adopts Shamir's t-out-of-n secret sharing scheme.
[0123] In addition, considering that the private model parameters of the client in federated learning are generally high-dimensional (10K) small integer (3-byte) vectors, this embodiment preferably packages such vectors into a single large integer, which is suitable for additive homomorphic secret sharing calculations and homomorphic chameleon hash calculations.
[0124] Preferably, this embodiment adopts a homomorphic chameleon hash algorithm based on discrete logarithm assumption, including:
[0125] · Common parameter generation CH.Gen(1 κ )→(CHpp=(p,G,g,h),TD=α), where g is is the generator of a cyclic group of order p, h is a group element
[0126] Hash value generation CH.Hash((p,G,g,h),x,r)→(ch=g x h r ),in
[0127] Hash verification CH.HashCheck((p,G,g,h),x,r,ch)→0 / 1, if ch=gx h r Then output 1, otherwise output 0;
[0128] ·CH.Adapt((p,G,g,h),α,x,r,ch,x′)→r′, where r′=(xx′+αr) / α.
[0129] It can be seen that the chameleon hash satisfies the correctness, homomorphism, collision resistance and indistinguishability based on the assumption of discrete logarithms.
[0130] Analysis of the polymerization effect of exemplary embodiments:
[0131] (1) Correctness of the aggregation result. When all parties execute the protocol honestly, the correctness of the additive homomorphic secret sharing algorithm can be used to deduce In addition, based on the homomorphism of the Chameleon hash algorithm, it can be guaranteed that CH.Hash(CHpp,y,r)=Π i∈[1,n] ch i The equation is established and the output is successful
[0132] (2) The honest client inputs parameter x i Under the random oracle model, the security of the present disclosure is based on the assumption of discrete logarithms and the security of the secret sharing algorithm.
[0133] (3) Verifiability of aggregation results: Verifiability is achieved based on the homomorphism and anti-collision properties of the Chameleon hash algorithm.
[0134] (4) Smaller client communication load. The present disclosure preferably adopts a non-interactive security aggregation method. During the entire process, the client only needs to submit once, which greatly saves communication bandwidth. In addition, it is noted that assuming there is a secure channel between the client and multiple servers, the present disclosure adopts the chameleon hash algorithm to implement it. The client only needs to upload 3 group elements to the server, which is one less group element than the existing multi-server security aggregation system based on a secure channel.
[0135] (5) Decentralized public parameter security - anti-malicious adversaries and anti-m-1 server collusion: Server Just make sure you follow the protocol and run it honestly. The distribution of CH.Gen(1 κ )Generated public parameters The distribution is consistent (because To generate randomly, is also random).
[0136] The above technical scheme is only an exemplary embodiment of the present invention. For those skilled in the art, it is easy to make various types of improvements or modifications based on the application methods and principles disclosed in the present invention, and it is not limited to the method described in the above specific embodiment of the present invention. Therefore, the method described above is only preferred and does not have a restrictive meaning.
Claims
1. A decentralized multi-server security aggregation system, characterized in that: include: Client, server, and bulletin board system maintained by the server, including: The bulletin board is the data exchange intermediary for all participants. All data output by the participants are uploaded to the bulletin board, and the required data can be downloaded from the bulletin board; The client is used to generate homomorphic chameleon random numbers and calculate the homomorphic chameleon hash value of its own private input; Based on additive homomorphic secret sharing, for different servers, they generate their own secret sharing shares of private input and homomorphic chameleon random numbers, encrypt the two with the server public key to generate ciphertext, and output the ciphertext and the homomorphic chameleon hash value; The server is used to participate in the generation of homomorphic chameleon hash public parameters with other servers and distribute them to all participants; generate its own public-private key pair and make the public key public; decrypt the collected ciphertext, secretly aggregate the secret sharing shares of each client, and output the aggregated result; The system is publicly verifiable, and any party can use the aggregation results published on the bulletin board and the homomorphic chameleon hash public parameters and homomorphic chameleon hash values to secretly reconstruct the aggregation results and verify the aggregation results based on the homomorphism of the chameleon hash function.
2. The security aggregation system according to claim 1, characterized in that: The system includes a cryptographic component running on the client and the server, and the cryptographic component includes: Public key encryption module, used to generate the server's public and private key pairs, encrypt messages sent by the client, and decrypt them on the server side; The additive homomorphic secret sharing module is used to generate secret sharing shares of private inputs and homomorphic chameleon random numbers for different servers based on additive homomorphic secret sharing, perform secret aggregation on the server side, and secretly reconstruct the aggregation results; The homomorphic chameleon hash module is used to generate homomorphic chameleon hash public parameters and homomorphic chameleon hash values, and to verify the aggregation results based on the homomorphism of the chameleon hash function.
3. A decentralized multi-server security aggregation method, comprising the following steps: Public parameter generation: Multiple servers jointly generate homomorphic chameleon hash public parameters and distribute them to all participants; Key generation: The server generates its own public-private key pair and publishes the public key; Input sharing generation: The client generates a homomorphic chameleon random number and calculates the homomorphic chameleon hash value of its own private input; Based on additive homomorphic secret sharing, different servers generate their own secret sharing shares of private input and homomorphic chameleon random numbers, which are encrypted with the server's public key to generate ciphertext, and the ciphertext and homomorphic chameleon hash value are output; Aggregation: The server decrypts the received ciphertext, aggregates the secret sharing shares received from each client, and outputs the aggregation result; Verification: Any participant uses the aggregation results published on the bulletin board and the homomorphic chameleon hash public parameters and homomorphic chameleon hash values to secretly reconstruct the aggregation results, and verify the aggregation results based on the homomorphism of the chameleon hash function; The data output by all participants are output to the bulletin board and the required data are downloaded from the bulletin board.
4. The multi-server security aggregation method according to claim 3, characterized in that: The method for generating common parameters adopts the method for the classic discrete logarithm problem The verification algorithm of the non-interactive zero-knowledge proof protocol after the Fiat-Shamir transformation: Given a common input ,in is a prime number and , for A subgroup of order p The generator of is a security parameter; the prover proves to the verifier that he knows Make , :The prover uses and private input As input, , (1) Provers are randomly selected , and calculate ; (2) For hash functions ,calculate ; (3) Calculation ; (4) Output Proof ; :The verifier uses and proof For input, (1) According to the above hash function ,calculate ; (2) Verify the equation whether it is established; (3) If the above equation holds, accept the proof and output 1; otherwise, reject the proof and input 0; server Random Selection , and calculate ,use ,Will public; server or client Both can run the verification algorithm of the above zero-knowledge proof protocol , in regard to If all are verified, we get As a homomorphic chameleon hash public parameter , where j=1,…m, m is the number of multiple servers in the aggregation system.
5. The multi-server security aggregation method according to claim 3, characterized in that: It also includes a step to package the client's private input parameters into a single large integer.
6. The multi-server security aggregation method according to claim 3, characterized in that: The RSA public key encryption algorithm is used for public-private key pair generation, public key encryption, and ciphertext decryption.
7. The multi-server security aggregation method according to claim 3, characterized in that: The additive homomorphic secret sharing adopts the Shamir secret sharing method to generate secret sharing shares, secret aggregation, and secret reconstruction of the aggregation result.
