Fog storage dynamic auditing and encryption deduplication method and system based on multiple copies

Abstract

The invention discloses a fog storage dynamic auditing and encryption deduplication system and method based on multiple copies. The system comprises a data preprocessing module, a user layer, a key generation module, a fog storage module, a data auditing module, a data PoW verification module, a data fault positioning module and a data updating module. The data preprocessing module obtains public system parameters by constructing a multiplication cycle group of a quadratic residual modulus; the fog storage module searches the uploaded data file through the fog node to judge the user type; the data auditing module is used for auditing a variable Merkel Hash tree and a label set in the fog storage module by constructing a multi-copy scene and carrying out fault query positioning after auditing fails; the data updating module dynamically modifies variable Merkel Hash trees and labels in the fog storage module and the data auditing module through a message lock encryption algorithm; the user layer downloads a file from the fog storage module and decrypts the file to obtain a data block plaintext; according to the method, the variable Merkel Hash tree and the RSA signature verification mechanism are combined to realize data integrity auditing and PoW verification, so that the problem of complicated certificate management in the combination of the existing data deduplication and auditing technologies is solved, and the technical problem of high calculation overhead is solved.

Description

Technical Field

[0001] The present invention belongs to the technical field of fog computing data privacy protection, and in particular relates to a fog storage dynamic audit and encryption deduplication method and system based on multiple copies. Background Art

[0002] In recent years, fog storage has provided users with convenient services, but many security issues have also emerged, among which data integrity issues are particularly important. In particular, more and more people are paying attention to the storage overhead of the data integrity audit process. Some inventions focus on combining data deduplication with data integrity auditing to ensure data integrity while reducing the system's storage overhead, especially combining proof of ownership (PoW) with provable data possession (PDP). However, most solutions often ignore the computational overhead and complex certificate management in the data audit and deduplication process. How to solve the high computational overhead and complex certificate management is a problem worth exploring. Furthermore, most inventions only support single-copy application scenarios, which is not conducive to recovering damaged data blocks in the event of an audit failure. How to achieve efficient fault location after an audit failure is also worth exploring.

[0003] Traditional inventions will generate different ciphertexts for the same file data blocks, resulting in audit failure. TPA can only perform binary copy verification on the challenged label set to locate the faulty copy node. However, the verification process requires a large number of bilinear pairings, resulting in high computational overhead. The present invention utilizes the consistency of data block ciphertext and labels. Once TPA finds that the audit has failed, it uses dynamic Bloom filters to efficiently locate data faults. It is worth noting that the model of the present invention is different from the traditional invention. In the traditional invention, all users share a file and updates must be performed synchronously among multiple users. In the model of the present invention, all users independently own the same file, and updates by one user should not affect other users. That is, when the original file has multiple owners, the replica node should store both the original version and the updated version of the file. Summary of the invention

[0004] In view of the existing technical problems, the present invention provides a method and system for dynamic auditing and encryption deduplication of fog storage based on multiple copies. The invention adopts a variable Merkle tree and an RSA signature verification mechanism to combine PoW with data integrity auditing, so as to solve the technical problems that the verification operation of bilinear pairing is used in the existing data deduplication and auditing technology, and the complex certificate management is required, and the computational overhead is high. At the same time, the invention uses a threshold-based proxy re-signature to enable each replica node to cooperate in generating a re-signature key, so as to ensure that the data remains associated with the user after deduplication in multiple replica scenarios, so as to solve the technical problem that most of the existing inventions combining deduplication and auditing consider a single replica scenario, but do not consider the situation of recovering data after an audit failure, and the multi-copy scenario is more suitable for the audit of a large file system. In addition, the invention combines an updateable message-locked encryption (UMLE, Updatable Block-Level Message-LockedEncryption) technology with a variable Merkle hash tree (VMHT, Variable Merkle Hash Tree) to achieve efficient data update, so as to solve the problem of high computational overhead in the dynamic auditing function in the prior art. The existing invention needs to recalculate the ciphertext and label of the data block in terms of dynamic data update, which greatly increases the computing overhead and requires a complex key management process; further, the present invention has the consistency of data block ciphertext-label, and can be combined with a dynamic Bloom filter to quickly locate faulty replica nodes and data blocks. In the process of fault location, in the event of audit verification failure, the damaged data blocks and labels can be quickly and accurately located.

[0005] In order to solve the problems of the prior art, the present invention adopts the following technical solutions:

[0006] A multi-copy based fog storage dynamic audit and encryption deduplication system, the system comprises: a data preprocessing module, a user layer, a key generation module, a fog storage module, a data audit module, a data PoW verification module, a data fault location module and a data update module; wherein:

[0007] The data preprocessing module obtains the common system parameters by constructing a multiplication cyclic group of quadratic residue moduli;

[0008] The fog storage module determines the user type by searching the uploaded data files through the fog nodes; including:

[0009] The user layer uploads the ciphertext CT with the updated message lock encrypted plaintext data block, and the fog node calculates the ID CT , check whether the fog storage module already has the ID CT ; If it exists, it is the second uploading user, otherwise it is the first uploading user; where:

[0010] If it is the first time for the user to upload, the key generation module generates a public key for the TPA, and configures a re-signature key and a message-derived key for the user who uploads for the first time; at the same time, the user layer uploads the variable Merkle hash tree related to the data block and the tag set to the fog storage module; the fog storage module performs PoW verification on the user who uploads for the second time to verify his ownership of the data block; and the key generation module configures a message-derived key and a re-signature key for the user who uploads for the second time;

[0011] The data audit module aggregates the data block ciphertext and label copy through the threshold proxy re-signature algorithm, and TPA audits the aggregated results; TPA performs fault query and location on the fog storage module after the audit fails;

[0012] The data update module dynamically modifies the variable Merkle hash tree and tag set in the fog storage module and the data audit module through an updated message lock encryption algorithm;

[0013] The user layer downloads the file from the fog storage module and decrypts it to obtain the plaintext data block.

[0014] Further, the user layer uploads the data block with the variable hash tree and the tag set in the first uploaded user file to the fog storage module; including:

[0015] Generate a plaintext data block by transferring the file according to the following formula:

[0016] F=F[1]||F[2]||…||F[n],

[0017] Initialize the variable hash tree using the following algorithm:

[0018] initialization

[0019] Set que = null

[0020] Setting F 1 ←F stF 1 ={F[Pr(sh,n)[1]],…,F[Pr(sh,n)[n]]}

[0021] Set F′ = k I |k 2 |…|k n , x=1, y=n+1

[0022] Construct the relevant information set of leaf nodes for the variable hash tree according to the following algorithm;

[0023]

[0024] Construct non-leaf nodes for the variable hash tree according to the following algorithm;

[0025]

[0026] Construct the master key kk of the variable hash tree root node for non-leaf nodes according to the following algorithm mas

[0027] F′=kk′ 1 |kk′ 2 |…|kk′ L

[0028] kk mas =H 0 (F′), CT y =Enc(kk mas , F′)

[0029] Create an attribute group for the root node v

[0030] <y,1,1,υ n′-1· ln+υn ′-2· ln,2,CT n′ 〉

[0031] Repeat the steps in lines 33-34

[0032] return A VMHT v,kk mas , c 1 , c 2 , …, c x , CT n+1 , CT n+2 ,…CT y

[0033] The user layer ciphertext for each leaf node of the variable hash tree Generate hash value h i =H(c i );

[0034] Establish the calculation label of each leaf node according to the following formula;

[0035]

[0036] Transform the variable Merkle hash tree and the label of each leaf node The data is sent to the fog storage module together.

[0037] Furthermore, the specific algorithm of the data audit module randomly selects different non-leaf nodes from the variable hash tree, and analyzes which leaf nodes the non-leaf node is composed of, and then generates a challenge c i ; The TPA will challenge ci Send to each fog node separately;

[0038] The specific algorithm of the data audit module is that the fog storage module retrieves each challenge c i The corresponding leaf node in the challenged data block set r 1 Search for the challenged data block label and aggregate the data block ciphertext and the corresponding label; at the same time, aggregate the generated aggregated labels from different fog nodes; the fog storage module generates proof and sends it to the data audit module;

[0039] The specific algorithm of the data audit module: The TPA calculates the hash value of the ciphertext data block Then the verification information is calculated; the TPA determines whether the data blocks and their labels stored on the fog storage module are complete by verifying the equation.

[0040] Furthermore, the data audit module performs a fault query and location process after the audit of the variable Merkle hash tree and the tag set in the fog storage module fails; including:

[0041] The ciphertexts of the audit challenge block set stored in the data audit module are mapped to the dynamic filter DBF in sequence, and the ciphertext sets of the copies stored in the fog storage module are input into DBF in sequence for query. If the query can be made, it means it is correct, otherwise it is a faulty data block; where:

[0042] Input the ciphertext set of the corresponding leaf nodes in the challenge set that failed verification, locate the ciphertext of the correct leaf node stored on it in the data audit module, and map the correct ciphertext to the static filter through hash; including finding an executable static filter in the current state, if not, create a new static Bloom filter; otherwise, map the ciphertext to the static filter SBF through hash; n r Indicates the current capacity of SBF. Once it is mapped to one of the bitmaps, it is +1.

[0043] Traverse u SBFs and perform query operations;

[0044] Map the ciphertext copies of the leaf node to be verified to u SBFs in sequence; perform k hash mappings on the ciphertext of the leaf node to be verified. If the search is successful, the mapping value is 1. When the cumulative mapping value is k, it means that the leaf node ciphertext can be queried, that is, the copy is correct.

[0045] Furthermore, the data update module dynamically modifies the variable Merkle hash tree and labels related to the data blocks in the fog storage module and the data audit module through the message lock encryption algorithm; including:

[0046] Modify operation: User layer to fog iSend the index i of the data block to be updated; fog i Find the data block and record the path v from the leaf node where the i-th data block is located to the root node path [2 h ],…,v path [i]; At the same time, find the label T corresponding to the data block to be modified i ; The fog storage module sends the path information to the user layer; The user layer uses the master key kk mas Decrypt the node ciphertext on the path, iterate the decryption and finally get F[i], which is modified to F[i] * ; The user layer calculates the modified variable hash tree master key through the message lock encryption algorithm and the label T′ of the modified data block i ; Finally, the user layer will T′ i , new path information v′ path [2 h ],……,v′ path [i] and the updated version number vv are packaged and sent to the fog storage module; at the same time, the user layer The version number vv is kept locally; the fog storage module saves all versions before and after the update, and each user controls their own version; the data audit module generates a new challenge C′ based on the updated variable hash tree i , the fog storage module is based on C′ i Generate the corresponding proof′={AGGT″,AGGT′ 1 , μ′}; the data audit module generates verification information VI′ and AGGT″, and executes equation Determine whether the data block is complete;

[0047] Add operation: The user layer sends the data block m to be added to the fog storage module i After receiving the index i, the fog storage module records the path v from the node where the i-th data block is located to the root node path [2 h ],…,v path [f]; and send the path information to the user layer; the user layer decrypts and adds the data block to calculate the updated ciphertext c′ i and label T′ i , and then recalculate the modified variable hash tree master key The user layer sends this data block to the new path information v′ of the root node path [2 h ],…,v′ path [2 h +1], data block information c′ i , T′ i, and the updated version number vv are sent to the fog storage module; the user layer will vv is retained locally; the fog storage module adds a new data block before the i-th data block and records the above-mentioned relevant updated leaf node information; updates the information of each node on the path;

[0048] Deletion operation: The user layer sends the index f of the data block to be deleted to the fog storage module; after receiving the index f, fog i Find the path v from the node where the fth data block is located to the root node path [2 h ],…,v path [f]; The fog storage module sends the node information on the path to the user layer; the user layer calculates the variable hash tree master key after deleting the data block Since the fth data block needs to be deleted, the user layer calculates the new path information v′ from this data block to the root node path [2 h ],…,v′ path [parent(i)]; the user layer will v′ path [2 h ],…,v′ path [parent(i)] and the updated version number vv are packaged and sent to the fog storage module; the user layer vv is kept locally; the fog storage module deletes the data block and its ciphertext c i , and update the information of each node on the path.

[0049] Beneficial Effects

[0050] Compared with the traditional technical solution, the beneficial effects brought by the present invention are:

[0051] Most of the existing inventions combining data deduplication and auditing technologies are based on bilinear pairing verification operations and require complex certificate management, but their computational overhead is high. The present invention describes a solution that combines PoW with data integrity auditing based on VMHT and RSA signature verification mechanism to reduce computational overhead.

[0052] In the existing deduplication and auditing scenarios, most of them consider the single copy scenario. However, for the case of recovering data after an audit failure, the multi-copy scenario is more suitable for auditing large file systems. In order to ensure that the data remains associated with the user after deduplication in the multi-copy scenario, the present invention uses threshold-based proxy re-signing to enable each replica node to cooperate in generating a re-signature key.

[0053] Most efficient auditing inventions often support the function of dynamically updating data blocks. How to achieve efficient updates based on the Message-Locked Encryption (MLE) algorithm is a question worth considering. UMLE has high update efficiency at the data block level and is compatible with the VMHT structure used in the present invention. Therefore, the present invention has a high update efficiency.

[0054] At the same time, once an incomplete set of data blocks is audited, it is also important to restore the complete data blocks. The present invention sets multiple fog nodes to store data block ciphertext copies and label copies for fault recovery. Traditional inventions will generate different ciphertexts for the same file data blocks, resulting in audit failure. TPA can only perform binary copy verification on the challenged label set to locate the faulty copy node. However, the verification process requires a large number of bilinear pairings, resulting in high computational overhead. The present invention utilizes the consistency of data block ciphertext and label. Once TPA finds that the audit has failed, it uses dynamic Bloom filters to efficiently locate data faults. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] Figure 1 It is a system model diagram of the present invention;

[0056] Figure 2 Flowchart of the data upload phase

[0057] Figure 3 A diagram of the VMHT structure related to the present invention;

[0058] Figure 4 This is a diagram of the UMLE encryption process related to the present invention;

[0059] Figure 5 It is a UMLE update process diagram of the present invention; DETAILED DESCRIPTION

[0060] The following is combined with Figure 1-Figure 5 The present invention is described as follows:

[0061] Most of the existing inventions combining PoW and PDP use bilinear pairing operations to verify the data ownership of the user who uploaded the second time and the integrity of the data block stored on the fog node. However, the multiple use of modular exponentiation and bilinear pairing increases the computational overhead of the system, which will bring a heavy computational burden to the system. At the same time, complex key management also increases the burden on the system. In view of this, the present invention provides a fog storage dynamic design and encryption deduplication system based on multiple copies and its method, which greatly reduces the computational overhead in the PoW and PDP process, while reducing the computational cost of PoW and improving the audit efficiency. Most efficient audit inventions often support the function of dynamic update of data blocks. How to achieve efficient update based on MLE is a question worth considering. UMLE is efficient in block-level updates and is compatible with the tree structure used in the present invention. Therefore, the present invention uses MLE technology to encrypt data blocks, so that exactly the same data blocks can generate exactly the same ciphertext, thereby ensuring the consistency of data block ciphertext and data block label. In order to deduplicate data block labels, message-derived keys are used to generate data block labels, and only users who upload for the first time need to generate data block labels. At the same time, once an incomplete set of data blocks is audited, it is also important to restore the complete data block. The present invention sets up multiple fog nodes to store ciphertext copies of data blocks and label copies for fault recovery. The following is the technical solution adopted by the present invention:

[0062] Step 1: System initialization: Generate a multiplication cyclic group based on the quadratic residue modulus and common system parameters;

[0063] Specifically include: Setup(1 λ )→P: Define the security key prime numbers p′, q′. KGC calculates the RSA modulus N=pq, where p=2p′+1, q=2q′+1 (both large prime numbers). Define a multiplication cyclic group QR based on the quadratic residue modulus N N , where g is QR N The generator of . Define a SHA1 hash function, an h: Choose a pseudo-random function, π 2 : Define a collision-resistant hash algorithm H, H 0 , enter 1 λ , output H: {0, 1} * →Z N , H 0 : {0, 1} * →{0, 1} λ . Define the common system parameters P = {g, N, h, π 2 ,H,H 0}.

[0064] Step 2: Determine whether the user is uploading for the first time: The fog node determines whether the user is the initial uploader or the second uploader by searching the data files uploaded by the user. The system generates a re-signature key pair for the user. If the user is uploading for the second time, the user will prove his ownership of the data block through the PoW protocol between the fog node. The system generates a derived key based on the data block information for the user, and then generates a re-signature key for the user;

[0065] Specifically: Assume that user U wants to upload a file to fog node fog i The data upload stage is shown in Table 1. U uses the message lock to encrypt the plaintext data block to obtain the ciphertext CT, fog i By calculating ID CT , check whether it already has the ID CT If it exists, it means that U is uploading for the first time, otherwise it is uploading for the second time. If U is uploading for the first time, KGC generates a public-private key pair for U through the algorithm in step 3. U constructs the data block into VMHT and uploads the generated tags to fog together. i The system generates a re-signature key pair for U using the algorithm in step 3. If U is uploading for the second time, U will i The PoW protocol between them is used to prove its ownership of the data block. The system generates a derived key MK based on the data block information for U through the algorithm in step three, and then generates a re-signature key for U according to the algorithm in step three.

[0066]

[0067] Table 1

[0068] Step 3: Generate keys for users: Generate a message-derived key and a re-signature key for the user uploading for the first time. Generate a re-signature key and a message-derived key for the user uploading for the second time.

[0069] User U enters security parameter 1 λ , KGC generates a key pair (pk, sk) for U. KGC generates a public key pk=e and a private key sk=s for the user, so that es≡1(modp′q′). Where e is a random and secure large prime number. In addition, the user selects a As a secret value. Let the plaintext data block F = F[1]||F[2]||…||F[n]. If the user is uploading data for the first time, then KGC needs to calculate a message-derived key for U. where k∈[1,n]. KGC then computes the corresponding message-derived public key If the user is uploading for the second time, the user needs to perform PoW authentication and calculate MK.

[0070] User U who uploads for the first / second time calculates the re-signing key so that fog i (Assuming there are p fog nodes, i∈[1, p]) can provide TPA with a valid proof based on U’s private key. KGC calculates the re-signing key RK for U i =(d,h 1 ), where d = s·(MK i ) -1 +r,h 1 = r·u. r is a group A random number in the system. N Upper constructor F(x) = ur + a 1 x+a 2 x 2 +…+a t-1 x t-1 , user U calculates the polynomial values ​​F(1), F(2), ..., F(n) (assuming there are n fog nodes in total), where F(0) = ur. U provides each fog node fog through a secure channel. i distribute As its private key, fog i The public key is The secret value F(0) = h can be recovered only when at least t fog nodes cooperate 1 .

[0071] Step 4: Data upload: The first-time user uploads the VMHT and label set based on the file data block to the fog node;

[0072] Initialize VMHT: This algorithm is executed by user U. The first uploaded user inputs a data block in plain text. First, Algorithm 1 inputs the file data block F = F[1]||F[2]||…||F[n] and outputs the variable Merkle hash tree VMHT. Lines 1-4 of the code define the initialization phase of VMHT. The third line passes k i =H 0 (F 1 [i]) Calculate F′. Lines 5-13 describe the construction of leaf nodes in VMHT. Each leaf node contains a tuple, in which the UMLE algorithm is used to generate the data block ciphertext to facilitate the update of subsequent data blocks. Lines 14-38 of the code construct the non-leaf nodes in VMHT. First, the UMLE algorithm is used to generate the data block ciphertext, and then it is determined whether the number of child nodes owned by the non-leaf node is 2 or 3. Then it iteratively generates non-leaf nodes. Finally, lines 39-40 introduce the master key for generating the VMHT root node, see Table 2.

[0073]

[0074] Table 2

[0075] U first encrypts the ciphertext of each leaf node Generate hash value h i =H(c i ). Next, U calculates the label for each leaf node U will be the variable Merkle hash tree VMHT and the label of each leaf node Send to fog i . U sends the public key pk and VMHT V to TPA.

[0076] Step 5: Data audit: TPA audits the VMHT and label sets stored on the fog nodes;

[0077] It includes three sub-algorithms: Challenge, ProofGen, and Auditing from TPA. Specifically, Challenge: The second line of code indicates that TPA randomly selects non-leaf nodes of different levels from the tree and analyzes which leaf nodes the non-leaf nodes are composed of (corresponding to lines 5-9 of code). TPA uses these leaf nodes as challenge blocks (line 17 of code). TPA then selects the leaf nodes from the group. Randomly select a seed d 2 . This constitutes C i ={D i , S i ,l,r,ln,d 2}. TPA will C i Send to each fog separately i . TPA for each j∈[1,ll 1 ]choose b j =π 2 (j,d 2 ) sends it to fog i , as shown in Table 3.

[0078]

[0079] Table 3

[0080] ProofGen: As shown in the algorithm in Table 4, fog i Retrieve each challenge C i The corresponding leaf node in Figure 4 1-5 of the code). Next, fog i According to the challenged data block set r 1 Search for the tag of the challenged data block (corresponding to Figure 4 Line 6 of the code) to calculate the aggregate label In addition, fog iThe set of data block ciphertexts for the computational challenge By the last fog node fog n calculate And aggregate the aggregated labels from different fog nodes to generate fog i Will Send to TPA.

[0081] Table 4

[0082]

[0083] Auditing from TPA: As shown in the algorithm in Table 5, TPA calculates the hash value of the ciphertext data block , thereby calculating the verification information: TPA received fog i After sending the proof, T is sent to U, and U calculates and generates TPA Acquisition TPA determines whether the data block and its tag are complete by verifying the following equation:

[0084]

[0085] Table 5

[0086]

[0087] Step 6: Perform PoW verification on the user who uploaded the data for the second time: The fog node performs PoW verification on the user who uploaded the data for the second time;

[0088] If the user's ID CT If it shows that it already exists, it means that the user is uploading the file for the second time. Then the user will connect to fog to prove the ownership of the file. i Execute the PoW protocol. The specific process is as follows:

[0089] ChalGen: Similar to the challenge generation process of audit, fog i From the group Randomly select a seed d 2 This constitutes a challenge C i =l, r, ln, d 3 .

[0090] ProofGen:U based on r 2 ,ll 2 Parse the corresponding challenged data block and for each j∈[1,ll 1 ]Calculate a j ∈r 2 , $bj =π 2 (j,d 3 )$. Then, U searches for the label of the challenged data block according to the challenged data block set r1, and then generates an aggregate label At the same time, U challenges C i Generate a subtree. Then U calculates In addition, U chooses a random number rr∈Z N , and calculate Finally, U will proof = {T, T 1 , μ, u} and the corresponding subtree root node ciphertext Together we form P i Pack and send to fog i U combines the auxiliary information of the node to be verified with C i Send to fog together i .

[0091] PoW Auditing from fog i :fog i According to Chal (t) The challenge data block and the auxiliary information AAI sent by U, fog i Retrieve these challenged blocks and generate the root node ciphertext CT′ root , and the stored root node ciphertext value CT root If they are the same, continue to verify the aggregation tag. Otherwise, it means that the verification failed, fog i The set of corrupted data blocks will be located based on the l and r of the data block. Once the root node ciphertext is the same, fog i Calculate the hash value of the data block ciphertext And calculate the verification information: U calculation generation Send to fog i 。 fog i U's ownership of the data copy is determined by verifying the following equation and comparing whether the ciphertext values ​​of the root nodes of the two subtrees are equal:

[0092]

[0093] If the verification is successful, it means that U has a copy of the data, fog i Store its re-signing key RK. Otherwise, U is not the actual owner of the data copy. If U is the actual owner of the data copy, the subsequent data integrity audit process is the same as before.

[0094] Step 7: Fault location: If the data audit fails, TPA locates the damaged data block and its label copy;

[0095] When TPA verification fails, it is possible to locate which sets of replicas have failed. The present invention uses a dynamic Bloom filter (DBF). Once the audit result is a failure, the ciphertext of the challenge block set stored in the TPA can be mapped to the DBF in sequence, and the ciphertext set of the replicas stored in the fog node can be input into the DBF in sequence for query. If it can be queried, it means it is correct, otherwise it is a faulty data block. The same is true for the method of verifying the data block label.

[0096] As shown in Table 6, first input the ciphertext set of the corresponding leaf node in the challenge set that failed verification, TPA locates the ciphertext of the correct leaf node stored on it, and maps the correct ciphertext to SBF through hash. The specific operation is as follows: check whether there is an Active SBF in the current state. If not, create a new SBF and add 1 to the value of u. If yes, map the ciphertext to the Active SBF through hash. r Indicates the current capacity of the SBF. If it is mapped to one of the bitmaps, it is +1.

[0097] Table 6

[0098]

[0099] As shown in Table 7, traverse u SBFs and perform query operations. Map the ciphertext copies of the leaf nodes to be verified to u SBFs in sequence. Perform k hash mappings on the ciphertext copies of the leaf nodes to be verified. If the search is successful, the mapping value is 1. When the cumulative mapping value is k, it means that the ciphertext of the leaf node can be queried, that is, the copy is correct.

[0100] Table 7

[0101]

[0102] Step 8: Dynamic update: The user applies for dynamic update of data blocks, and the fog nodes and TPA use UMLE to update the data blocks and labels stored on them;

[0103] Modification operation: When user U applies to modify a data block, it needs to pass fog i The specific process is as follows: U moves to fog i Send the index i of the data block to be updated. fog i Find the data block and record the path v from the leaf node where the i-th data block is located to the root node path [2 h ],…,v path [i] (assuming the tree height is h). Next, fog i Find the label T corresponding to the data block to be modified i Finally, fogi The path information is sent to U. U uses the master key kk mas Decrypt the node ciphertext on the path, iterate the decryption and finally get F[f], which is modified to F[f] * .Depend on Figure 5 As shown, U obtains the modified VMHT master key through UMLE calculation and the label T′ of the modified data block i Finally, U converts T′ i , new path information v′ path [2 h ],……,v′ path [i] and the updated version number vv are packaged and sent to fog i . General U The version number vv is kept locally. fog i All versions before and after the update are saved in the , and each user controls their own version. TPA generates a new challenge C′ based on the updated VMHT i , fog i According to C′ i Generate the corresponding proof′={AGGT″,AGGT′ 1 , μ′}. TPA generates verification information VI′ and AGGT″ and executes Eq. Determine whether the data block is complete.

[0104] Add operation: Similar to the process of modifying a data block. When the user wants to add a data block, he needs to use fog i The specific process is as follows: The user sends a message to fog. i Send the data block m to be added i 。 fog i After receiving index i, fog i Record the path v from the node where the i-th data block is located to the root node path [2 h ],…,v path [i]. Finally, fog i The path information is sent to U. After decryption, U adds the data block and calculates its ciphertext c′ i and label T′ i , and then recalculate the modified VMHT master key U takes this data block to the new path information v′ of the root node path [2 h ],…,v′ path [2 h +1], data block information c′ i , T′ i, and send the updated version number vv to fog i . General U vv remains local. fog i Add a new data block before the i-th data block and record its information set. i Update the information set of each node on the path.

[0105] Deletion operation: When the user wants to delete a data block, he needs to use fog i The specific process is as follows: The user sends a message to fog i Send the index of the data block to be deleted i. i After receiving index i, fog i Find the path v from the node where the i-th data block is located to the root node path [2 h ],…,v path [i]. Finally, fogi sends the node information on the path to U. U calculates the VMHT master key after deleting the data block. Since the fth data block needs to be deleted, U calculates the new path information v′ from this data block to the root node path [2 h ],…,v′ path [parent(i)]. Finally, U converts v′ path [2 h ],…,v′ path [parent(i)] and the updated version number vv are packaged and sent to fog i . General U vv remains local. fog i Delete the data block and its ciphertext c i , and update the information of each node on the path. The audit process is the same as above.

[0106] Step 9: User decryption: The user downloads the file from the fog node and decrypts it to obtain the plaintext;

[0107] As shown in Table 8; if fog i If the data block stored on is complete, then U requests to download the data and decrypts it to get the plain text. The decryption process is divided into the decryption of the data block key and the decryption of the data block ciphertext. The specific process is as follows: U inputs the root node master key kk mas, and the ciphertext of each non-leaf node. It shows the process of decrypting step by step from the root node layer to the previous layer of the leaf node. The plaintext of the parent node obtained by decryption can be divided into the keys of its child nodes, thereby obtaining the plaintext of the child nodes, and iterating this process. The last 9-12 lines determine whether the number of child nodes of the parent node is an odd number. If so, one more key will be divided (that is, when the number of nodes of VMHT is 2 n +1). When U obtains k 1 , …, k n After that, through F i = Dec(k i , c i ) decrypts the data block to obtain the plaintext, where i∈[1,n].

[0108] Table 8

[0109]

[0110] Although the present invention has been described above, the present invention is not limited to the above-mentioned specific embodiments. The above-mentioned specific embodiments are merely illustrative and not restrictive. Under the guidance of the present invention, ordinary technicians in this field can make many modifications without departing from the purpose of the present invention, which are all within the protection of the present invention.

Claims

1. A fog storage dynamic audit and encryption deduplication system based on multiple copies, characterized by; The system includes: a data preprocessing module, a user layer, a key generation module, a fog storage module, a data audit module, a data PoW verification module, a data fault location module and a data update module; wherein: The data preprocessing module obtains the common system parameters by constructing a multiplication cyclic group of quadratic residue moduli; The fog storage module determines the user type by searching the uploaded data files through the fog nodes; including: The user layer uploads the ciphertext CT with the updated message lock encrypted plaintext data block, and the fog node calculates the ID CT , check whether the fog storage module already has the ID CT ; If it exists, it is the second uploading user, otherwise it is the first uploading user; where: If it is the first time for the user to upload, the key generation module generates a public key for the TPA, and configures a re-signature key and a message-derived key for the user who uploads for the first time; at the same time, the user layer uploads the variable Merkle hash tree related to the data block and the tag set to the fog storage module; the fog storage module performs PoW verification on the user who uploads for the second time to verify his ownership of the data block; and the key generation module configures a message-derived key and a re-signature key for the user who uploads for the second time; The data audit module aggregates the data block ciphertext and label copy through the threshold proxy re-signature algorithm, and TPA audits the aggregated results; TPA performs fault query and location on the fog storage module after the audit fails; The data update module dynamically modifies the variable Merkle hash tree and tag set in the fog storage module and the data audit module through an updated message lock encryption algorithm; The user layer downloads the file from the fog storage module and decrypts it to obtain the plaintext data block.

2. According to the multi-copy-based fog storage dynamic audit and encryption deduplication system of claim 1, it is characterized by: The user layer uploads the data block with the variable hash tree and the tag set in the first uploaded user file to the fog storage module; including: Generate a plaintext data block by transferring the file according to the following formula: F=F[1]||F[2]||…||F[n], Initialize the variable hash tree using the following algorithm: Initialize L = n, Set que = null Setting F l ←F stF1={F[Pr(sh,n)[1]],...,F[Pr(sh,n)[n]]} Set F′=k1|k2|...|k n , x=1, y=n+1 Construct the relevant information set of leaf nodes for the variable hash tree according to the following algorithm; Construct non-leaf nodes for the variable hash tree according to the following algorithm; Construct the master key kk of the variable hash tree root node for non-leaf nodes according to the following algorithm mas F′=kk′1|kk′2|...|kk′ L kk max =H0(F′),CT y =Enc(kk max ,F′) Create an attribute group for the root node υ <y,1,1,v n′-1 .ln+v n′-2 ·ln,2,CT n′ > Repeat the steps in lines 33-34. return A VMHT v,kk max ,c1,c2,...c x ,CT n+1 ,CT n+2 ,...CT y The user layer ciphertext for each leaf node of the variable hash tree Generate hash value h i =H(c i ); Establish the calculation label of each leaf node according to the following formula; The variable Merkle hash tree and the label of each leaf node W = {{T i (k) } i∈[1，n] } is sent to the fog storage module.

3. According to the multi-copy-based fog storage dynamic audit and encryption deduplication system of claim 2, it is characterized by: The specific algorithm of the data audit module randomly selects different non-leaf nodes from the variable hash tree, and analyzes which leaf nodes the non-leaf node is composed of, and then generates a challenge C i ; The TPA will challenge C i Send to each fog node separately; The specific algorithm of the data audit module is that the fog storage module retrieves each challenge C i The corresponding leaf node in the fog node; search for the challenged data block label according to the challenged data block set r1, and aggregate the data block ciphertext and the corresponding label; at the same time, aggregate the generated aggregated label from different fog nodes; the fog storage module generates proof and sends it to the data audit module; The specific algorithm of the data audit module: The TPA calculates the hash value of the ciphertext data block Then the verification information is calculated; the TPA determines whether the data blocks and their labels stored on the fog storage module are complete by verifying the equation.

4. According to the multi-copy-based fog storage dynamic audit and encryption deduplication system of claim 1, it is characterized by: The data audit module performs a fault query and location process after the audit of the variable Merkle hash tree and the tag set in the fog storage module fails; including: The ciphertexts of the audit challenge block set stored in the data audit module are mapped to the dynamic filter DBF in sequence, and the ciphertext sets of the copies stored in the fog storage module are input into DBF in sequence for query. If the query can be made, it means it is correct, otherwise it is a faulty data block; where: Input the ciphertext set of the corresponding leaf nodes in the challenge set that failed verification, locate the ciphertext of the correct leaf node stored on it in the data audit module, and map the correct ciphertext to the static filter through hash; including finding an executable static filter in the current state, if not, create a new static Bloom filter; otherwise, map the ciphertext to the static filter SBF through hash; n r Indicates the current capacity of SBF. Once it is mapped to one of the bitmaps, it is +1. Traverse u SBFs and perform query operations; Map the ciphertext copies of the leaf node to be verified to u SBFs in sequence; perform k hash mappings on the ciphertext of the leaf node to be verified. If the search is successful, the mapping value is 1. When the cumulative mapping value is k, it means that the leaf node ciphertext can be queried, that is, the copy is correct.

5. According to the multi-copy-based fog storage dynamic audit and encryption deduplication system of claim 1, it is characterized by: The data update module dynamically modifies the variable Merkle hash tree and labels related to the data blocks in the fog storage module and the data audit module through the message lock encryption algorithm; including: Modify operation: User layer to fog i Send the index i of the data block to be updated; fog i Find the data block and record the path v from the leaf node where the i-th data block is located to the root node path [2 h ],…,v path [i]; At the same time, find the label T corresponding to the data block to be modified i ; The fog storage module sends the path information to the user layer; The user layer uses the master key kk mas Decrypt the node ciphertext on the path, iterate the decryption and finally get F[i], which is modified to F[i] * ; The user layer calculates the modified variable hash tree master key through the message lock encryption algorithm and the label T′ of the modified data block i ; Finally, the user layer will T′ i , new path information v′ path [2 h ],……,v′ path [i] and the updated version number vv are packaged and sent to the fog storage module; at the same time, the user layer The version number vv is kept locally; the fog storage module saves all versions before and after the update, and each user controls their own version; the data audit module generates a new challenge C′ based on the updated variable hash tree i , the fog storage module is based on C′ i Generate the corresponding proof′={AGGT″,AGGT′1,μ′}; the data audit module generates verification information VI′ and AGGT″, and executes equation Determine whether the data block is complete; Add operation: The user layer sends the data block m to be added to the fog storage module i After receiving the index i, the fog storage module records the path v from the node where the i-th data block is located to the root node path [2 h ],…,v path [i]; and send the path information to the user layer; the user layer decrypts and adds the data block to calculate the updated ciphertext c′ i and label T′ i , and then recalculate the modified variable hash tree master key The user layer sends this data block to the new path information v′ of the root node path [2 h ],…,v′ path [2 h +1], data block information c′ i , T′ i , and the updated version number vv are sent to the fog storage module; the user layer will vv is retained locally; the fog storage module adds a new data block before the i-th data block and records the above-mentioned relevant updated leaf node information; updates the information of each node on the path; Deletion operation: The user layer sends the index i of the data block to be deleted to the fog storage module; after receiving the index i, fog i Find the path v from the node where the i-th data block is located to the root node path [2 h ],…,v path [i]; The fog storage module sends the node information on the path to the user layer; the user layer calculates the variable hash tree master key after deleting the data block Since the i-th data block needs to be deleted, the user layer calculates the new path information v′ from this data block to the root node path [2 h ],…,v′ path [parent(i)]; the user layer will v′ path [2 h ],…,v′ path [parent(i)] and the updated version number vv are packaged and sent to the fog storage module; the user layer vv is kept locally; the fog storage module deletes the data block and its ciphertext c i , and update the information of each node on the path.

6. A dynamic audit and encryption deduplication method for fog storage based on multiple copies, characterized by: The method is performed based on any one of claims 1 to 5.

Images