A Multi-Factor SM9 Blind Signature Big Data Privacy Protection Method and System

Abstract

This invention discloses a multi-factor SM9 blind signature big data privacy protection method and system, relating to the field of privacy protection technology. The method includes: acquiring user-related data; performing information blinding processing on the user-related data based on user nodes to obtain blinded data; sending the blinded data to a signing node; the signing node performing signature processing on the blinded data to obtain signed information data; sending the signed information data to both the user node and a verification node; the user node deblinding the signed information data to obtain a real signature; sending the real signature to the verification node; and the verification node using the real signature to verify the signed information data. If verification fails, the user-related data is reacquired and processed for verification again. If verification succeeds, privacy-protected data is obtained.

Description

Technical Field

[0001] This invention relates to the field of privacy protection technology, specifically a multi-factor SM9 blind signature big data privacy protection method and system. Background Technology

[0002] Data is a key driving force behind today's technological revolution and social progress. In today's information age, where emerging technologies are developing rapidly, large-scale models are artificial intelligence models with massive amounts of training data and powerful computing capabilities. Relying on computing power, they can handle complex large-scale dataset analysis tasks and provide accurate predictions and decision support. However, the rapid development and widespread application of large-scale model technology heavily relies on data, and data-related issues, such as data security, immediately become apparent. Models that create a large-scale model ecosystem through multi-party interaction, sharing, and trading of data are gradually gaining acceptance. However, massive amounts of data often contain sensitive information during large-scale model training and application processing. Ensuring the privacy of this data and the security of the data owner's identity during multi-party interaction has become an urgent problem to be solved. At the same time, the reasoning ability of generative artificial intelligence may generate private information in the datasets after large-scale model training. This private information should be hidden and protected, and how to efficiently process this private data is also a major challenge. Summary of the Invention

[0003] To address the shortcomings mentioned in the background section, the present invention aims to provide a multi-factor SM9 blind signature big data privacy protection method and system.

[0004] Firstly, the objective of this invention can be achieved through the following technical solution: a multi-factor SM9 blind signature big data privacy protection method, the method comprising the following steps:

[0005] Obtain user-related data, perform information blinding processing on the user-related data based on the user node to obtain blinded data, and send the blinded data to the signature node;

[0006] The signing node will sign the blinded data to obtain the signed information data, and then send the signed information data to the user node and the verification node.

[0007] User nodes deblind the signed information data to obtain the real signature, and send the real signature to the verification node. The verification node uses the real signature to verify the signed information data. If the verification fails, it re-obtains the user-related data and processes and verifies it again. If the verification is successful, it obtains the privacy-protected data.

[0008] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: the user-related data includes user identity ID = γ, timestamp T = τ, and one-time password OTP = λ.

[0009] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: building and implementing the system within the blockchain system, and performing system initialization on the model system.

[0010] Define a finite field and elliptic curves An elliptic curve generates two additive groups, G1 and G2, and there exists a bilinear mapping e: G1 × G2 → G T , where GT is the multiplicative group; select the private key s according to the key generation center KGC, and calculate P. pub =s·G1,P pub As the public key, User selects the private key d. User And calculate its public key P User =d User ·G1.

[0011] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: the process of performing information blinding processing on user-related data:

[0012] The signature node Psigner in group G T Calculate g = e(P1, P) pub ); Randomly select an integer r from [1, n-1]; In group G T Calculate w = g r And send w to user node User; obtain the three elements γ, τ, and λ, and send them to user node User; after receiving w, user node User uses γ and μ as blinding parameters according to the three elements; user node User in group G T Calculate w2 = w γ g μ User node continues to calculate h = H2(M||w2,N) and BM = γ -1 h-ζ, where ζ is the twist line parameter, and the blinded data BM is sent to the signature node Psigner.

[0013] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: the process by which the verification node verifies the signed information data using the real signature.

[0014] Verifier user node calculates g = e(P1, P pub ); Calculate t = g h ; Calculate h1 = H1(ID) A||hid,N); Calculate P = [h1]P2 + P pub ; Calculate u = e(S,P); Calculate w' = u·t; Calculate h' = H2(M|w',N); Verify whether h' = h is true. If it is true, the verification passes; otherwise, the verification fails.

[0015] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: the key exchange protocol utilizes a variant of elliptic curve Diffie-Hellman (ECDH) to implement secure key exchange between end-to-end devices, as shown below: User node User and signing node Psigner establish a shared session key K. session This represents a unique authentication identifier for both parties involved in the data exchange, used for identity verification.

[0016] Both parties each choose an elliptic curve E:y 2 =x 3 The points on +ax+b(mod p) are used as the private key, denoted as d. User and d Signer , where G is a base point on the elliptic curve, a and b are the parameters of the curve, and p is a large prime number;

[0017] Both parties calculate the corresponding public key Q User =d User *G and Q Signer =d Signer *G and swap; then User will d User Send to Psigner, Psigner will d Signer The message is sent to the User, who then calculates the shared key K with the Psigner. User =d User *Q Signer and K Signer =d Signer *Q User Due to the additive property of elliptic curves, K User =K Signer =K, both parties share the same shared key K;

[0018] Introduce the bilinear mapping e: E1 × E2 → G T Where E1 and E2 are two different elliptic curves, G T It is another elliptic curve group, and the bilinear mapping satisfies the following property: bilinearity: for all P∈E1, Q∈E2, There is e(u a ·P,v b ·Q)=e(P,Q) ab Non-degeneracy: For non-infinitesimal P and Q, there exists

[0019] A secure key derivation function (KDF) is constructed using bilinear mappings and hash functions: K session =KDF(K,ID) User ID Signer ,TS); where KDF is a secure key derivation function, ID User and ID Signer These are the identifiers for User and Signer, respectively. TS is the timestamp, and KDF(K, ID) is the identifier for Signer. User ID Signer ,TS)=H(e(K,α)||ID User ||ID Signer ||TS), where α is a randomly selected auxiliary element on E2, || denotes the concatenation operation, and ID User and ID Signer These are the identifiers for devices A and B, respectively.

[0020] The information related to the public key, shared key, and session key generated during the key exchange process is stored on the blockchain.

[0021] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: the key generation center KGC verifies the uniqueness of the generated key using a conventional cuckoo filter, the steps of which are: initializing the cuckoo filter: the cuckoo filter consists of two hash tables H1 and H2 and four hash functions h1, h2, h3, h4; user key generation: user User requests key generation from KGC, and KGC generates a unique private key d for user User. U And calculate the corresponding public key P U =d U • G1, the hash function maps the key to an index in the hash table; public key uniqueness verification and insertion: User User inserts public key P U Send to KGC, KGC uses hash functions h1 and h2 to hash P U Perform hashing to obtain two index positions i = h1(P) U ) and j = h2(P U KGC checks H1[i] = P U or At this time P U If H2[j] = P, then H1[i] is inserted into H1[i]. U or P U If P is inserted into H2[j], U If it does not match either H1[i] or H2[j], and neither of these positions is empty, KGC will attempt to find P using kick-out and replacement operations. U The location.

[0022] In conjunction with the first aspect, in some implementations of the first aspect, the method further includes: an improved process for the conventional cuckoo filtering:

[0023] Add a timestamp field to each hash table entry or use a counter to track the usage of each entry, and update the timestamp or counter of the relevant hash table entry whenever a public key is looked up or inserted.

[0024] An additional ordered linked list data structure is used to maintain the LRU order of all hash table entries. When a hash table entry needs to be evicted to insert a new public key, the oldest entry is selected for evictment.

[0025] When it is necessary to remove an entry from H1 or H2 to insert a new entry P U When the hash function h1 and h2 are used, the following steps are performed: H1[i] and H2[j] are used to determine the possible positions i and j of the new entry; H1[i] and H2[j] are checked to see if they are empty or if they are related to P. U If neither matches and the position is not empty, select one LRU entry from H1[i] and H2[j] to evict; if the selection is to evict from H1[i], use h3 to determine P. old The new position k' in H2; P old Insert H2[k'] and update its usage record;

[0026] Key storage update and lookup verification

[0027] Once P U Upon successful insertion, KGC updates the cuckoo filter and auxiliary data structures to reflect this change, when public key P needs to be verified. U When determining whether a value is unique, KGC only needs to search for P in H1 and H2. U Verify its existence and check its usage records.

[0028] Secondly, in order to achieve the above objectives, this invention discloses a multi-factor SM9 blind signature big data privacy protection system, comprising:

[0029] The blinding processing module is used to acquire user-related data, perform information blinding processing on the user-related data based on the user node, obtain blinded data, and the user node sends the blinded data to the signature node.

[0030] The signature processing module is used by the signature node to sign the blinded data, obtain the signed information data, and send the signed information data to the user node and the verification node.

[0031] The information verification module is used by user nodes to deblind and obtain the real signature from the signed information data. The real signature is then sent to the verification node, which uses the real signature to verify the signed information data. If the verification fails, the user-related data is retrieved again for reprocessing and verification. If the verification is successful, the privacy-protected data is obtained.

[0032] In another aspect of the present invention, in order to achieve the above-mentioned objective, a terminal device is disclosed, including a memory, a processor, and a computer program stored in the memory and capable of running on the processor. The memory stores the computer program capable of running on the processor, and when the processor loads and executes the computer program, it employs a multi-factor SM9 blind signature big data privacy protection method as described above.

[0033] The beneficial effects of this invention are:

[0034] This invention addresses the privacy challenges encountered in multi-party interactions with large-scale model data. Looking towards the future, it proposes a constructive approach to privacy protection for large-scale model data based on blockchain technology. Utilizing the SM9 algorithm and blind signatures, it performs partial privacy blind signatures on data requiring anonymity. Backed by blockchain signature authentication, it achieves partially anonymized data interaction. The invention relies on algorithms to strongly bind the user's identity during data interaction, eliminating the possibility of malicious actions at each authentication and interaction step. Combined with the public nature of blockchain, it protects data privacy by ensuring that user identity tampering is impossible. Simultaneously, it proposes an improved Least Recently Used (LRU) cuckoo filter strategy to verify and optimize the uniqueness of keys generated by the Key Generation Center (KGC) that the algorithm needs to access, ensuring efficient processing of the uniqueness of each generated key. Compared to existing solutions, the improved SM9 and identity authentication methods in this invention have undergone correctness and security analysis and comparison, achieving a 4.7x / 5.9x improvement in efficiency for the blind signature verification stage compared to the SM2 / Schnorr scheme while ensuring data security. Attached Figure Description

[0035] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0036] Figure 1 This is a schematic diagram of the method flow of the present invention;

[0037] Figure 2 This is a schematic diagram of the system architecture of the present invention;

[0038] Figure 3 This is a schematic diagram comparing the time of the present invention with four algorithm schemes throughout the entire process;

[0039] Figure 4 This is a schematic diagram comparing the time consumption of the key deduplication operation algorithm of this invention;

[0040] Figure 5 This is a schematic diagram of the system structure of the present invention. Detailed Implementation

[0041] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making any creative efforts shall fall within the scope of protection of the present invention.

[0042] Example 1:

[0043] The following is a description of the relevant terms used in the embodiments of this application:

[0044] Blockchain (also known as blockchain or blockchain chain) is a decentralized distributed ledger that is stored in blocks, is immutable, secure, and reliable. It combines distributed storage, peer-to-peer transmission, consensus mechanisms, and cryptography to record transactions and information through a continuously growing chain of data blocks, ensuring data security and transparency. Originating with Bitcoin, blockchain has evolved into a global technology, attracting global attention and investment. Subsequently, the emergence of next-generation blockchain platforms such as Ethereum further expanded its application areas. The characteristics of blockchain include decentralization, immutability, transparency, security, and programmability. Each data block is linked to the previous block, forming a continuous chain that ensures the integrity of transaction history. Smart contract technology makes blockchain programmable, supporting a wider range of applications. Blockchain is widely used in finance, supply chain, healthcare, real estate, and other fields. Although it still faces scalability and regulatory challenges, it has become a powerful tool for changing traditional business and social models and has enormous potential for the future.

[0045] like Figure 1 As shown, a multi-factor SM9 blind signature big data privacy protection method includes the following steps:

[0046] S101: Obtain user-related data, perform information blinding processing on the user-related data based on the user node to obtain blinded data, and send the blinded data to the signature node.

[0047] Specifically, user-related data includes user identification ID = γ, timestamp T = τ, and one-time password OTP = λ. Multi-factor SM9 blind signatures are implemented to protect privacy while providing relatively native, high-quality data for large-scale model training and multi-party data exchange. The SM9 algorithm is also used for authoritative authentication of data exchange parties and blockchain verifiers. Furthermore, an improved cuckoo filter is introduced in the KGC key generation stage for collision detection. Based on the massive data volume, the improved scheme proposes a dynamically adjusted least recently used hash table, solving the problem of KGC key uniqueness in SM9. The overall system's blind signature feature allows sensitive data that needs to be concealed within large amounts of data to be publicly verified and leaked via the blockchain, while maintaining high efficiency.

[0048] The solution is implemented within a blockchain system, where data providers are collectively referred to as User nodes, and data acquirers, who also act as data verifiers, are collectively referred to as Verifier nodes. User nodes and Verifier nodes interact with each other using their own signature key pairs. The most crucial node in the system is the Signer node, which signs the data. The Signer is also responsible for block generation, configuring multi-factor parameters, initializing SM9 blind signatures and subsequent authentication methods, and managing system transaction data.

[0049] The following steps constitute the process of scheme design and corresponding description:

[0050] (1) Perform system initialization on the model system.

[0051] Define a finite field and elliptic curves An elliptic curve generates two additive groups, G1 and G2, and there exists a bilinear mapping e: G1 × G2 → G T , where GT is the multiplicative group. The private key s is selected according to the Key Generation Center (KGC), and P is calculated. pub =s·G1,P pub As the public key. User selects private key d. User And calculate its public key P User =d User ·G1.

[0052] (2) Information blinding processing

[0053] To ensure the privacy and integrity of message M, the blockchain system requires user node User to perform a blind signature on the message M that needs to be blinded. User first processes the one-time random number OTP, ID, and trusted timestamp T received from Psigner. Since timestamps may be duplicated, OTP and T are multiplied by τ*λ = μ. Then, the information is blinded using two random parameters, γ and μ, resulting in the blinded message BM.

[0054] (3) The signature node performs the signature.

[0055] After being blinded, the information BM is sent to the signing node Psigner in the blockchain network. The signing node Psigner signs the information and then sends the signed information M' to the user User.

[0056] (4) Unblinding and verifying signatures

[0057] User deblinds and signs the information M'. After successful verification, the user obtains the real signature (h,s) and sends h to the verifying user Verifier. At the same time, the user notifies the signing node to send the information M' to the verifying user Verifier.

[0058] (5) Verification of signature

[0059] The user verifies the blinded information M' using a signature. If the consistency check passes, the signature verification is successful, meaning the obtained message is data information that has been blinded and not tampered with by the user User.

[0060] The process of blinding user-related data:

[0061] The signature node Psigner in group G T Calculate g = e(P1, P) pub ); Randomly select an integer r from [1, n-1]; In group G T Calculate w = g r And send w to user node User; obtain the three elements γ, τ, and λ, and send them to user node User; after receiving w, user node User uses γ and μ as blinding parameters according to the three elements; user node User in group G T Calculate w2 = w γ g μ User node continues to calculate h = H2(M||w2,N) and BM = γ -1 h-ζ, where ζ is the twist line parameter, and the blinded data BM is sent to the signature node Psigner.

[0062] S102: The signing node will sign the blinded data to obtain the signed information data, and send the signed information data to the user node and the verification node.

[0063] Signature verification is performed through the following eight steps: 1. The signature verification user node Verifier calculates g = e(P1, P... pub 2. Calculate t = g h 3. Calculate h1 = H1(ID) A ||hid,N); 4. Calculate P=[h1]P2+P pub 5. Calculate u = e(S,P); 6. Calculate w' = u·t; 7. Calculate h' = H2(M|w',N); 8. Verify whether h' = h is true. If it is true, the verification passes; otherwise, the verification fails.

[0064] The method described in this invention addresses privacy protection measures for original information during information and key transmission. However, during interactions, malicious actors may impersonate users, verifiers, or signers. In such cases, user identity verification is necessary to ensure secure data transmission. To address this, this invention introduces a new key exchange protocol based on blockchain technology, utilizing bilinear mapping to improve upon existing SM9-based authentication methods.

[0065] The key exchange protocol described in this invention utilizes a variant of the elliptic curve Diffie-Hellman (ECDH) algorithm to achieve secure key exchange between end-to-end devices. Using the above use case notation as an example, the protocol can be represented as follows: User node User wants to establish a shared session key K with signing node Psigner. session This is a unique authentication identifier for both parties involved in data exchange, used for identity verification. The steps are as follows.

[0066] Initialize elliptic curve parameters

[0067] Both parties each choose an elliptic curve E:y 2 =x 3 The points on +ax+b(mod p) are used as the private key, denoted as d. User and d Signer , where G is a base point on the elliptic curve, usually chosen to satisfy the curve equation and have a suitable order (i.e., there exists a large prime number n such that nG = Θ, where Θ is an infinite point), a and b are parameters of the curve, and p is a large prime number.

[0068] Key generation and exchange

[0069] Both parties calculate the corresponding public key Q User =d User *G and Q Signer=d Signer *G and swap; then User will d User Send to Psigner, Psigner will d Signer The message is sent to the User, who then calculates the shared key K with the Psigner. User =d User *Q Signer and K Signer =d Signer *Q User Due to the additive property of elliptic curves, K User =K Signer =K, therefore both parties have the same shared key K, which can be used for subsequent encrypted communication.

[0070] Bilinear mapping introduction

[0071] To further enhance security, a bilinear mapping e: E1 × E2 → G is introduced. T Where E1 and E2 are two different elliptic curves, G T It is another elliptic curve group. Bilinear mappings satisfy the following property: bilinearity: for all P∈E1, Q∈E2, There is e(u a ·P,v b ·Q)=e(P,Q) ab Non-degeneracy: For non-infinitesimal P and Q, there exists

[0072] Session key derivation

[0073] A secure key derivation function (KDF) is constructed using bilinear mappings and hash functions to derive session keys from shared keys: K session =KDF(K,ID) User ID Signer (TS). Here, KDF is a secure key derivation function, ID User and ID Signer These are the identifiers for User and Psigner, respectively. TS is a timestamp used to ensure the validity of the session key. KDF(K,ID) User ID Signer ,TS)=H(e(K,α)||ID User ||ID Signer ||TS), where α is a randomly selected auxiliary element on E2, || denotes the concatenation operation, and ID User and ID Signer These are the identifiers for devices A and B, respectively.

[0074] Secure storage on the blockchain

[0075] The public key, shared key, and session key information generated during the key exchange process are stored on the blockchain to ensure their immutability and traceability.

[0076] S103: The user node deblinds the signed information data to obtain the real signature, and sends the real signature to the verification node. The verification node uses the real signature to verify the signed information data. If the verification fails, it re-obtains the user-related data and processes and verifies it again. If the verification is successful, the privacy-protected data is obtained.

[0077] Through the above steps, the algorithm's logic guarantees the authenticity and validity of the key, making it impossible for malicious nodes to attempt to breach the defense and disrupt normal operations. Specific scenarios are illustrated in the following section.

[0078] In the scheme described in this invention, to verify the uniqueness of the key generated by the Key Generation Center (KGC), the conventional cuckoo filtering steps are as follows: (1) Initialize the cuckoo filter: The cuckoo filter consists of two hash tables H1 and H2 and four hash functions h1, h2, h3, and h4. (2) User key generation: User requests the KGC to generate a key, and the KGC generates a unique private key d for it. U And calculate the corresponding public key P U =d U ·G1. These hash functions map the key to an index in the hash table. (3) Public key uniqueness verification and insertion: User User inserts public key P U Send to KGC, KGC uses hash functions h1 and h2 to hash P U Perform a hash operation to obtain two possible index positions i = h1(P). U ) and j = h2(P U KGC checks H1[i] = P U or At this time P U It is inserted into H1[i], and similarly, if H2[j] = P U or P U It is inserted into H2[j]. If P U If it does not match either H1[i] or H2[j], and neither of these positions is empty, KGC will attempt to find P using kick-out and replacement operations. U The location.

[0079] This invention discloses a multi-factor SM9 blind signature big data privacy protection method. Addressing the characteristic of large-scale generative data requiring repeated training, this invention improves the cuckoo filter by adding a hash table and ordered linked list internally for auxiliary replacement strategy optimization. This invention innovatively proposes a Least Recently Used (LRU) cuckoo filter strategy for key overwrite updates. The strategy's internal authentication information synchronization expiration mechanism means that data deleted by the LRU filter in the blind signature part is synchronized to the authenticated user. If it is the last piece of data, the authenticated user is synchronously deleted. Similarly, at the authentication stage, if a user's authentication fails, their corresponding data is synchronously deleted, reducing resource redundancy. Specific steps are as follows.

[0080] (1) Maintain usage records

[0081] Add a timestamp field or use a counter to track the usage of each entry for each hash table entry. Update the timestamp or counter of the relevant hash table entry whenever a public key is looked up or inserted.

[0082] (2) LRU kick-out strategy

[0083] An additional ordered linked list data structure is used to maintain the LRU order of all hash table entries. When a hash table entry needs to be evicted to insert a new public key, the oldest entry (i.e., the one with the earliest timestamp or the lowest usage count) is selected for evictment.

[0084] (3) Optimization of the kick-out and replacement process

[0085] When it is necessary to remove an entry from H1 or H2 to insert a new entry P U When the hash function h1 and h2 are used, the following steps are performed: 1. Use hash functions h1 and h2 to determine the possible positions i and j of the new entry; 2. Check whether H1[i] and H2[j] are empty or whether they are related to P. U 3. If neither matches and the position is not empty, select one LRU entry from H1[i] and H2[j] to evict; 4. If the selection is to evict from H1[i], use h3 to determine P. old The new position k' in H2; 5. Place P old Insert H2[k'] and update its usage record.

[0086] (4) Key storage update and lookup verification

[0087] Once P U Upon successful insertion, KGC updates the cuckoo filter and auxiliary data structures to reflect this change. When public key P needs to be verified... U When determining whether a value is unique, KGC only needs to search for P in H1 and H2. U Verify its existence and check its usage records.

[0088] Specifically, the present invention will be further illustrated below through embodiments:

[0089] This invention addresses the privacy challenges encountered in multi-party interactions with large-scale model data. Looking towards the future, it proposes a constructive approach to privacy protection for large-scale model data based on blockchain technology. Utilizing the SM9 algorithm and blind signatures, it performs partial privacy blind signatures on data requiring anonymity. Backed by blockchain signature authentication, it achieves partially anonymized data interaction. The invention relies on algorithms to strongly bind the user's identity during data interaction, eliminating the possibility of malicious actions at each authentication and interaction step. Combined with the public nature of blockchain, it protects data privacy by ensuring that user identity tampering is impossible. Simultaneously, it proposes an improved Least Recently Used (LRU) cuckoo filter strategy to verify and optimize the uniqueness of keys generated by the Key Generation Center (KGC) that the algorithm needs to access, ensuring efficient processing of the uniqueness of each generated key. Compared to existing solutions, the improved SM9 and identity authentication methods in this invention have undergone correctness and security analysis and comparison, achieving a 4.7x / 5.9x improvement in efficiency for the blind signature verification stage compared to the SM2 / Schnorr scheme while ensuring data security.

[0090] This example compares the performance of the SM2-based, elliptic curve-based Schnorr blind signature algorithm, and RSA-based blind signature algorithm using the five grouped datasets mentioned earlier. The experiment divides the complete process into four stages, and the four algorithms are compared at each stage and in terms of total time consumption, as detailed in the appendix. Figure 3 As shown, the execution speeds of the four blind signature algorithms differ at different stages. In the blinding stage with 5000 data points, the SM2-based blind signature algorithm runs the fastest. In the blind signature and deblinding stages with different data volumes, the operation times of the SM2-based and Schnorr-based elliptic curve algorithms are similar, while the RSA-based algorithm exhibits slower processing time. The proposed solution is significantly slower than all the comparative solutions. As the amount of test data increases, the increase in processing time of this solution is significantly lower than that of other comparative groups. Although there are some stages with similar processing time to existing solutions when the data volume is small, the overall processing time is consistently better than other solutions, which is also due to the optimization of the filtering strategy in the improved Cuckoo algorithm. With increasing data volume, this solution, relying on the innovative algorithm strategy, can effectively reduce the processing time of privacy data interaction, and the increase in processing time with increasing data volume is significantly lower than the conventional average increase. This solution provides significant time optimization while ensuring security. Taking the capped data volume experimental group as an example, the RSA solution is not compared due to its high value. The overall time efficiency of this solution is 4.7 times and 5.9 times that of the SM2 / Schnorr solutions.

[0091] In this example, the efficiency analysis of the Cuckoo Filter uses 10,000 / 20,000 / 60,000 / 100,000 / 160,000 keys generated by the SM9 algorithm in the above grouping experiment as the test dataset. The data is subjected to KGC raw query operations, and key deduplication is compared using the Cuckoo Filter and the improved Cuckoo Filter proposed in this paper. The query performance under different data scales is tested. The test results are attached. Figure 4 As shown in the figure, as the amount of experimental key data increased from 10,000 to 60,000, a significant difference emerged among the three comparison algorithms. Because the original KGC algorithm has a unique ID attribute, there were no collisions after the query, thus eliminating the need for a replacement step. The replacement operation in the Cuckoo algorithm resulted in the highest processing time. The improved Cuckoo algorithm, with its strategy specifically designed for large datasets, still experienced collisions, but the overall processing time was reduced by approximately 10ms. With further increases in the test data volume, the reduction in processing time became more significant compared to other algorithms, and its growth was relatively slow, with the runtime not increasing linearly. The experimental data shows that the improved Cuckoo filter demonstrated excellent performance across various data volumes, especially when handling large datasets, where its optimization efficiency was particularly pronounced.

[0092] Example 2: Second aspect, such as Figure 5 As shown, to achieve the above objectives, a multi-factor SM9 blind signature big data privacy protection system includes:

[0093] The blinding processing module 11 is used to acquire user-related data, perform information blinding processing on the user-related data based on the user node, obtain blinded processing data, and send the blinded processing data to the signature node.

[0094] The signature processing module 12 is used by the signature node to sign the blinded data, obtain the signed information data, and send the signed information data to the user node and the verification node.

[0095] The information verification module 13 is used by user nodes to deblind and obtain the real signature of the signed information data, and send the real signature to the verification node. The verification node uses the real signature to verify the signed information data. If the verification fails, the user-related data is retrieved again and processed for verification again. If the verification is successful, the privacy-protected data is obtained.

[0096] Based on the same inventive concept, this invention also provides a computer device, comprising: one or more processors, and a memory for storing one or more computer programs; the programs include program instructions, and the processor executes the program instructions stored in the memory. The processor may be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. It is the computing and control core of the terminal, used to implement one or more instructions, specifically for loading and executing one or more instructions stored in a computer storage medium to implement the above-described method.

[0097] It should be further explained that, based on the same inventive concept, the present invention also provides a computer storage medium storing a computer program, which, when executed by a processor, performs the above-described method. This storage medium can be any combination of one or more computer-readable media. The computer-readable medium can be a computer-readable signal medium or a computer-readable storage medium. The computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media (a non-exhaustive list) include: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In the present invention, the computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

[0098] In the description of this specification, references to terms such as "an embodiment," "example," "specific example," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this disclosure. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0099] The foregoing has shown and described the basic principles, main features, and advantages of this disclosure. Those skilled in the art should understand that this disclosure is not limited to the above embodiments. The embodiments and descriptions in the specification are merely illustrative of the principles of this disclosure. Various changes and modifications can be made to this disclosure without departing from its spirit and scope, and all such changes and modifications fall within the scope of this disclosure as claimed.

Claims

1. A multi-factor SM9 blind signature big data privacy protection method, characterized in that, The method includes the following steps: Obtain user-related data, perform information blinding processing on the user-related data based on the user node to obtain blinded data, and send the blinded data to the signature node; The user-related data includes user identification ID = γ, timestamp T = τ, and one-time password OTP = λ; The blockchain system is built and implemented, and the model system is initialized: Define a finite field and elliptic curves An elliptic curve generates two additive groups, G1 and G2, and there exists a bilinear mapping e: G1 × G2 → G T , where GT is the multiplicative group; select the private key s according to the key generation center KGC, and calculate P. pub =s·G1,P pub As the public key, User selects the private key d. User And calculate its public key P User =d User ·G1; The process of blinding user-related data: The signature node Psigner in group G T Calculate g = e(P1, P) pub ); Randomly select an integer r from [1, n-1]; In group G T Calculate w = g r And send w to user node User; obtain the three elements γ, τ, and λ, and send them to user node User; after receiving w, user node User uses γ and μ as blinding parameters according to the three elements; user node User in group G T Calculate w2 = w γ g μ User node continues to calculate h = H2(M||w2,N) and BM = γ -1 h-ζ, where ζ is the twist line parameter, and the blinded data BM is sent to the signature node Psigner; The signing node will sign the blinded data to obtain the signed information data, and then send the signed information data to the user node and the verification node. User nodes deblind the signed information data to obtain the real signature, and send the real signature to the verification node. The verification node uses the real signature to verify the signed information data. If the verification fails, it re-obtains the user-related data and processes and verifies it again. If the verification is successful, it obtains the privacy-protected data.

2. The multi-factor SM9 blind signature big data privacy protection method according to claim 1, characterized in that, The process by which the verification node verifies the signed information data using the real signature: Verifier user node calculates g = e(P1, P pub ); Calculate t = g h ; Calculate h1 = H1(ID) A ||hid,N); Calculate P = [h1]P2 + P pub ; Calculate u = e(S,P); Calculate w' = u·t; Calculate h' = H2(M|w',N); Verify whether h' = h is true. If it is true, the verification passes; otherwise, the verification fails.

3. The multi-factor SM9 blind signature big data privacy protection method according to claim 1, characterized in that, The key exchange protocol utilizes a variant of the elliptic curve Diffie-Hellman ECDH to achieve secure key exchange between end-to-end devices, as shown below: User node User and signing node Psigner establish a shared session key K. session This represents a unique authentication identifier for both parties involved in the data exchange, used for identity verification. Both parties each choose an elliptic curve E:y 2 =x 3 The points on +ax+b(mod p) are used as the private key, denoted as d. User and d Signer , where G is a base point on the elliptic curve, a and b are the parameters of the curve, and p is a large prime number; Both parties calculate the corresponding public key Q User =d User *G and Q Signer =d Signer *G and interchange; Then User will d User Send to Psigner, Psigner will d Signer The message is sent to the User, who then calculates the shared key K with the Psigner. User =d User *Q Signer and K Signer =d Signer *Q User Due to the additive property of elliptic curves, K User =K Signer =K, both parties share the same shared key K; Introduce the bilinear mapping e: E1 × E2 → G T Where E1 and E2 are two different elliptic curves, G T It is another elliptic curve group, and the bilinear mapping satisfies the following property: bilinearity: for all P∈E1, Q∈E2, There is e(u a ·P,v b ·Q)=e(P,Q) ab Non-degeneracy: For non-infinitesimal P and Q, there exists A secure key derivation function (KDF) is constructed using bilinear mappings and hash functions: K session =KDF(K,ID) User ID Signer ,TS); where KDF is a secure key derivation function, ID User and ID Signer These are the identifiers for User and Signer, respectively. TS is the timestamp, and KDF(K, ID) is the identifier for Signer. User ID Signer ,TS)=H(e(K,α)||ID User ||ID Signer ||TS), where α is a randomly selected auxiliary element on E2, || denotes the concatenation operation, and ID User and ID Signer These are the identifiers for devices A and B, respectively. The information related to the public key, shared key, and session key generated during the key exchange process is stored on the blockchain.

4. The multi-factor SM9 blind signature big data privacy protection method according to claim 1, characterized in that, The Key Generation Center (KGC) verifies the uniqueness of the generated keys using a standard cuckoo filter. The steps are as follows: Initialize the cuckoo filter: The cuckoo filter consists of two hash tables H1 and H2 and four hash functions h1, h2, h3, and h4; User key generation: User requests a key from KGC, and KGC generates a unique private key d for them. U And calculate the corresponding public key P U =d U • G1, the hash function maps the key to an index in the hash table; Public key uniqueness verification and insertion: User User inserts public key P U Send to KGC, KGC uses hash functions h1 and h2 to hash P U Perform hashing to obtain two index positions i = h1(P) U ) and j = h2(P U KGC checks H1[i] = P U or At this time P U If H2[j] = P, then H1[i] is inserted into H1[i]. U or P U If P is inserted into H2[j], U If it does not match either H1[i] or H2[j], and neither of these positions is empty, KGC will attempt to find P using kick-out and replacement operations. U The location.

5. The multi-factor SM9 blind signature big data privacy protection method according to claim 4, characterized in that, The improvement process of the conventional cuckoo filter: Add a timestamp field to each hash table entry or use a counter to track the usage of each entry, and update the timestamp or counter of the relevant hash table entry whenever a public key is looked up or inserted. An additional ordered linked list data structure is used to maintain the LRU order of all hash table entries; when a hash table entry needs to be evicted to insert a new public key, the oldest entry is selected for evictment; When it is necessary to remove an entry from H1 or H2 to insert a new entry P U When the hash function h1 and h2 are used, the following steps are performed: H1[i] and H2[j] are used to determine the possible positions i and j of the new entry; H1[i] and H2[j] are checked to see if they are empty or if they are related to P. U If neither matches and the position is not empty, select one LRU entry from H1[i] and H2[j] to evict; if the selection is to evict from H1[i], use h3 to determine P. old The new position k' in H2; P old Insert H2[k'] and update its usage record; Key storage update and lookup verification Once P U Upon successful insertion, KGC updates the cuckoo filter and auxiliary data structures to reflect this change, when public key P needs to be verified. U When determining whether a value is unique, KGC only needs to search for P in H1 and H2. U Verify its existence and check its usage records.

6. A multi-factor SM9 blind signature big data privacy protection system, employing the multi-factor SM9 blind signature big data privacy protection method according to any one of claims 1 to 5, characterized in that, include: The blinding processing module is used to acquire user-related data, perform information blinding processing on the user-related data based on the user node, obtain blinded data, and the user node sends the blinded data to the signature node. The signature processing module is used by the signature node to sign the blinded data, obtain the signed information data, and send the signed information data to the user node and the verification node. The information verification module is used by user nodes to deblind and obtain the real signature from the signed information data. The real signature is then sent to the verification node, which uses the real signature to verify the signed information data. If the verification fails, the user-related data is retrieved again for reprocessing and verification. If the verification is successful, the privacy-protected data is obtained.

7. A terminal device, comprising a memory, a processor, and a computer program stored in the memory and capable of running on the processor, characterized in that, The memory stores a computer program that can run on the processor. When the processor loads and executes the computer program, it employs a multi-factor SM9 blind signature big data privacy protection method according to any one of claims 1 to 5.

Images