A group-oriented efficient dynamic data integrity auditing method

Abstract

The present application relates to a kind of group-oriented efficient dynamic data integrity auditing method.The method of the present application includes the following steps:1) system parameter initialization;2) group user generates public-private key pair;3) group user generates group file integrity auditing label with anonymity according to group information;4) third-party auditor constructs hash chain table;5) third-party auditor and cloud storage server interact to generate data integrity auditing result;6) group user dynamically modifies data, and third-party auditor updates hash chain table, and cloud storage server modifies storage data.The present application is needed for the identity management of multi-user collaboration system, and supplements the data ownership proof method in the existing multi-user collaboration system, realizes that data ownership can be traced to real signature user while being anonymous to outside world.Secondly, for the frequent data dynamic operation in multi-user collaboration system, a new data structure is proposed to further reduce the overhead caused by data dynamic.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of cloud storage data integrity auditing, and particularly relates to a group-oriented efficient dynamic data integrity auditing method. BACKGROUND

[0002] With the continuous development of cloud computing technology, cloud storage services have been widely used in practice, providing convenience for users in their daily learning, work and life. Users upload local storage data to the cloud to obtain more powerful, more economical and higher quality storage. In addition, in some cloud multi-user collaboration systems, multiple users jointly own the same file and perform real-time editing, updating and sharing, which not only promotes team collaboration but also significantly improves work efficiency. However, while users enjoy efficient and convenient storage services, they have lost physical control over data. Since the cloud storage system is not completely trustworthy, the maintenance of data integrity on the cloud is one of the key concerns of users when using cloud storage services. If data is tampered with or lost during storage, it will directly lead to service interruption and even cause economic losses, affecting the healthy development of the cloud storage service market.

[0003] At present, the field of cloud storage data integrity auditing has made certain progress, especially represented by the data possession proof (Provable Data Possession, PDP) and the data retrievability proof (Proof of Retrievability, PoR). However, these methods can only provide efficient static data integrity auditing. If the user dynamically modifies the data, it will destroy the consistency of the data block index and the data label index, so it is necessary to retrieve a large amount of data locally for modification and then re-upload, which will significantly increase the computational overhead. More seriously, in multi-user collaboration systems, multiple users simultaneously own and frequently modify the same file, leading to further increase in computational cost. Obviously, these solutions will impose a heavy computational burden on users and are difficult to adapt to the needs of actual production environments.

[0004] To this end, to alleviate this conflict, the existing solution is to maintain the consistency of the data block index and the data tag index by adding additional data structures, so that the location of the data block no longer depends on the user's earliest setting, but can change as the user requires, thereby reducing the cost of dynamic data update. The existing data structures include skip list, hash number, hash table, etc. However, if the existing dynamic data integrity auditing scheme is directly applied to the multi-user collaboration system, the following three problems will exist: 1) the file cannot be shared: in the existing scheme, the ownership of the file belongs to a single user, which prevents other collaboration members from effectively sharing or accessing the file, thereby limiting the flexibility and efficiency of team cooperation; 2) user identity privacy leakage: since the data integrity auditing tag is generated by the key pair related to the user's identity, the user's identity may be exposed during the auditing process, increasing the risk of identity privacy leakage, especially in a public or temporary cooperation environment; 3) large overhead of file modification operation: the existing scheme needs to update the additional data structure from top to bottom when processing dynamic file modification, resulting in high computational cost. In a multi-user collaboration system, frequent dynamic data operations further increase the computational burden of the system, affecting the overall performance. SUMMARY

[0005] Therefore, the purpose of the present application is to provide a group-oriented efficient dynamic data integrity auditing method, which solves the problems of file sharing, user identity privacy leakage and large overhead of file modification operation when the existing dynamic data integrity auditing scheme is directly applied to the multi-user collaboration system.

[0006] To achieve the above purpose, the technical scheme adopted by the present application is as follows: a group-oriented efficient dynamic data integrity auditing method, comprising the following steps:

[0007] Step 1: the system generates global public parameters param based on security parameters l, selects a multiplicative cyclic group G with a safe prime number p as the order, randomly selects two independent generators g and h, and selects a hash function H to G group; Let the system parameters param={G, p, g, h, H};

[0008] Step 2: the group user generates a key and a public key according to the system parameters, selects two random elements (x j , y j )←Z p , and sets the private key sk j =(x j , y j ), and calculates the public key

[0009] Step 3: the group user generates an integrity auditing tag with anonymity;

[0010] Step 4: The third-party auditor constructs a hash chain table, calculates the data block index r1, r n ; initializes the hash chain table node A1 = {N1 = n, head1→r1, tail1→r n}, where N is the number of data blocks stored by the node, head1 is the first data block index stored by the node, and tail1 is the last data block index stored by the node;

[0011] Step 5: The third-party auditor interacts with the cloud storage server to generate data integrity audit results;

[0012] Step 6: The group user dynamically modifies the data, and the third-party auditor efficiently updates the hash chain table.

[0013] In a preferred embodiment, the step 3 includes the following steps:

[0014] Step 31: The group file F is divided into n data blocks m i of the same size, and m i is further divided into s data blocks m ij of the same size, where (1≤i≤n, 1≤j≤s), and s is the number of group users, and the index information r i of the data block m i is calculated according to the linear function f;

[0015] Step 32: The group user π anonymously generates an integrity audit tag for the data block m i , and calculates the event signature x π is the private key of the group user π, two random numbers are selected, and where r i is the index of the data block m i ; and the verification auxiliary information The integrity audit tag of the data block m i is generated

[0016] Step 33: After the group user anonymously generates the integrity proof tag for each data block, the group file F integrity audit tag set Tag = {tag i} 1≤i≤n is generated; the cloud storage server and the third-party auditor can trace the user identity according to the integrity audit tag, and verify whether different integrity audit tags are generated by the same group user.

[0017] In a preferred embodiment, the step 33 includes the following steps:

[0018] Step 331: Obtain integrity audit tags tag1 = {t1, ·}, tag2 = {t2, ·}, verify the validity of the integrity audit tags;

[0019] Step 332: Compare t1 and t2, if equal, then data blocks m1 and m2 are generated by the same group of users, return the verification result linked, otherwise data blocks m1 and m2 are generated by different groups of users, return the verification result unlinked.

[0020] In a preferred embodiment, the step 5 comprises the following steps:

[0021] Step 51: The third-party auditor randomly selects a subset I consisting of c elements from the data block set [1, n]; for each c in the challenge set i , select a random number v i , traverse the hash chain table to obtain the index r i ; randomly select an element a in the finite field Z p ; calculate H(r i ) = a(H(r i ) + 1) to generate a random challenge Q = (H(r i ), i, v i} i∈I ;

[0022] Step 52: The cloud storage server finds the corresponding data block m i and its tag according to the challenge set Q, calculates and generates the integrity proof P = (σ, K, Z, X, Y, (μ j} (1≤j≤s) , (τ i} i∈Q ), where:

[0023]

[0024]

[0025]

[0026] Step 53: The third-party auditor verifies the integrity proof P = (σ, K, Z, X, Y, (μ j} (1<j<s) , (τ i} i∈Q ) according to the challenge Q = (H(r i ), i, v i} i∈IThe event e = H(event) is calculated, and the group user public key set γ is used to verify whether equation (1) holds true.

[0027]

[0028] Calculate the parameters using the verified auxiliary data 'a'. Calculate and verify whether equation (2) holds true:

[0029]

[0030] Only when both equations (1) and (2) are true is the integrity verification result considered correct and the audit result "accept" returned; otherwise, the integrity of the cloud storage server data is compromised and the audit result "reject" returned.

[0031] In a preferred embodiment, step 6 includes the following steps:

[0032] Step 61: Data Insertion: Insert a data block after point i for group users, randomly selecting the insertion index r′←Z. p The insertion position i, r′ and operation op="insert" are sent to the third-party auditor; the third-party auditor calls Algorithm 1 to obtain the insertion position (j, i) of the data in the hash list. * ), indicating that the data index is located in hash block A. j Inner i * After the block, Algorithm 2 is called to update the hash chain;

[0033] Step 62: Data Deletion: The group user deletes the data block at position i, and sends i and the operation op="delete" to the third-party auditor, where i is the deletion position; the third-party auditor calls Algorithm 1 to obtain the deletion position (j, i) of the data in the hash chain. * Then, Algorithm 3 is called to update the hash chain;

[0034] Step 63: Data Modification: Group users will modify data block m i Change to m i Generate corresponding tags i ′, will m i ′, tag i Uploaded to the cloud storage server.

[0035] In a preferred embodiment, the specific steps of Algorithm 1, Algorithm 2, and Algorithm 3 mentioned in step 6 are as follows:

[0036] (1) Algorithm 1: Input data position i, output data position (j, i) in the hash chain. * Let the hash chain ∏ = {A1, ..., A2} be a linked list.c}, where A j ={N j head j , tail j} represents a node in the hash chain; traverse node A in the hash chain. j , where (1≤j≤c); let i * =i, compare i sequentially * With N j The size of i; if i * >N j Then let i * =i * -N j ; if i * ≤N j Then return (j, i) * End the traversal;

[0037] (2) Algorithm 2: Input (j, i * Let r' be a hash list ∏, and output the updated hash list ∏'; Let the hash list ∏ = {A1, ..., A2}. c}, where A j ={N j head j , tail j} represents a node in the hash chain; if i * =N j Let A j ={N j =N j +1, head j →head j , tail1→r′); if i * ≠N j Then a new node A is generated. j+1 ={N j+1 =N j -i * head j+1 →head j +i * , tail j+1 →tail j Let A j ={N j =i * +1, head j →head j ,tail1→r′};

[0038] (3) Algorithm 3: Input (j, i *Let r' be a hash list ∏, and output the updated hash list ∏'; Let the hash list ∏ = {A1, ..., A2}. c}, where A j ={N j head j , tail j} represents a node in the hash chain; if i * =N j Let A j ={N j =N j -1, head j →head j tail1→head j +(i * -2)}; if i * ≠N j Generate a new node A j+1 ={N j+1 =N j -i * head j+1 →head j +i * , tail j+1 →tail j Let A j ={N j =i * -1, head j →head j tail1→head j +(i * -2)}.

[0039] Compared with the prior art, the present invention has the following beneficial effects:

[0040] 1. The dynamic data integrity auditing method of the present invention allows files to be effectively shared within a group, ensuring that all collaborating members can access and modify files in real time, thereby improving the efficiency and flexibility of team collaboration.

[0041] 2. The dynamic data integrity auditing method of the present invention allows group users to generate anonymous group file integrity auditing tags based on group information, avoiding the risk of user identity being exposed during the auditing process. It is especially suitable for public or temporary collaborative environments, achieving anonymity of data ownership to the outside world while tracing the real signing user, effectively improving user identity privacy protection and system reliability.

[0042] 3、The dynamic data integrity auditing method of the application is aimed at frequent data dynamic operation in a multi-user collaboration system, proposes a new data structure, hash linked list, uses a small number of nodes to store a large amount of data index, and optimizes storage overhead. When the data dynamically changes, the hash linked list is efficiently updated by generating a new node, so that the data index is still arranged in order, and the storage data index can be quickly obtained according to a linear function through a pointer, and the time is constant, thereby improving the dynamic data auditing efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0043] Figure 1 The system initialization and generation of integrity auditing label flow chart in the method of the application;

[0044] Figure 2 The data integrity auditing flow chart in the method of the application;

[0045] Figure 3 The dynamic data modification flow chart in the method of the application;

[0046] Figure 4 The hash linked list data structure schematic diagram in the method of the application. DETAILED DESCRIPTION

[0047] The application will be further described below in combination with the drawings and examples.

[0048] It should be noted that the following detailed description is all exemplary and is intended to provide further explanation of the present application. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the present application belongs.

[0049] It should be noted that the terms used herein are only for the purpose of describing specific embodiments, and are not intended to limit the exemplary embodiments according to the present application; as used herein, unless the context clearly indicates otherwise, the singular form is also intended to include the plural form, and furthermore, it should be understood that when the terms "comprise" and / or "include" are used in the specification, there is a feature, step, operation, device, component and / or combination thereof.

[0050] The system model of the application is composed of group users (GU), cloud storage server (CSS) and third-party auditor (TPA).

[0051] (1) The group users (GU): The group is composed of multiple users, and has several collaborative files. Before uploading the files to the cloud storage server, the group users generate the group file integrity audit label with anonymity according to the group information, and dynamically modify the files according to the needs. The group members are the owners of the files, and are the only ones who can dynamically update the files, and entrust the third-party auditors to conduct the audit.

[0052] (2) The cloud storage server (CSS): The cloud storage server has powerful computing and storage resources, is responsible for complete storage and maintenance of the collaborative files uploaded by the group users, accepts the audit of the third-party auditors, and charges the corresponding storage and management fees. However, due to economic interests or reputation considerations, the cloud storage server may maliciously delete the group user files or conceal the data damage.

[0053] (3) The third-party auditor (TPA): The third-party auditor has stronger computing resources and management ability than the group users, is entrusted by the group users, is responsible for maintaining the hash chain table and conducting the integrity audit on the data in the cloud storage server. The third-party auditor only has the supervision right on the data in the cloud storage server, and cannot make any modification on the data.

[0054] The specific algorithm of the application is as follows:

[0055] (1) System parameter generation algorithm SysGen (1 λ )→param: The system runs the algorithm to generate the public parameters required by the system, and the algorithm takes the security parameter λ as the input, and outputs the public parameter param.

[0056] (2) Public key and private key generation algorithm KeyGen (param)→(sk j , pk j ): The group user runs the algorithm to generate the public key and the private key, and the algorithm takes the related system parameter param as the input, and outputs the private key and the public key pair (sk j , pk j ).

[0057] (3) Data label generation algorithm TagGen (event, s, γ, sx π , m i , param)→tag i : The group user runs the algorithm to generate the integrity audit label tag i with anonymity for the data m i . The algorithm takes the event event, the number of group members s, the group member public key set γ=(pk1, pk2,..., pks ), the user's private key sk π , data block m i and system parameter param as inputs, outputs the integrity audit tag tag i .

[0058] (4) Challenge set generation algorithm ChalGen(c)→Q: The third-party auditor runs this algorithm to generate the challenge set of this sampling inspection. The algorithm takes the number of data blocks of the sampling inspection c as input, and outputs the challenge set Q of this sampling inspection.

[0059] (5) Evidence generation algorithm ProofGen(Q, tag i , m i )→P: The cloud storage server runs this algorithm to obtain the data tag and data block of the sampling inspection, and generates the evidence P responding to the challenge this time. The algorithm inputs the challenge set Q, the data tag tag i of the sampling inspection, and the data block m i of the sampling inspection, and outputs the evidence P.

[0060] (6) Verification algorithm ProofVerify(event, s, γ, P, param)→accept / reject: The third-party auditor runs this algorithm to verify the integrity of the data of the cloud storage server. The algorithm inputs the event event, the number of group users s, the public key set γ=(pk1, pk2,..., pk s ), the evidence P, and the system parameter param, and outputs the verification result. If the output result is accept, it means that the data stored in the cloud storage server is complete and reliable, and if the output result is reject, it means that the data stored in the cloud storage server is damaged.

[0061] (7) Linking verification algorithm Link(event, s, γ, tag1, tag2)→linked / unlinked: The group user, the third-party auditor and the online collaboration system can run this algorithm to determine whether different integrity audit tags are generated by the same group user. The algorithm inputs the event event, the number of group users s, the public key set γ=(pk1, pk2,..., pk s ) and the integrity audit tags tag1, tag2, and outputs the verification result. If the output result is linked, it means that the integrity audit tags are generated by the same user, and if the output result is unlinked, it means that the integrity audit tags are not generated by the same user.

[0062] (8) Dynamic data modification algorithm Modify(i, r, op, ∏)→∏': Group users and third-party auditors run the algorithm to dynamically update the hash chain table. The algorithm inputs the position i of the data block, the index r of the data block i (only when the data insertion operation is needed), a dynamic data operation op (wherein op has three types of operations: inserting data, deleting data, and modifying data), and a hash chain table ∏, and outputs the updated hash chain table ∏'.

[0063] The group-oriented efficient dynamic data integrity auditing method provided by the application comprises the following steps:

[0064] (1) The system generates global public parameters param based on a security parameter λ, selects a multiplicative cyclic group G with a safe prime number p as the order, randomly selects two independent generators g and h, and selects a hash function H to the G group; the system parameters param=(G, p, g, h, H} are set;

[0065] (2) The group user generates a secret key and a public key according to the system parameters, selects two random elements (x j , y j )←Z p , and sets the secret key sk j =(x j , y j ), and calculates the public key

[0066] (3) The group user generates an integrity auditing label with anonymity, comprising the following steps:

[0067] (3-1) The group file F is divided into n data blocks m i of the same size, and m i is further divided into s data blocks m ij of the same size, wherein (1≤i≤n, 1≤j≤s), and s is the number of group users, and the index information r i of the data block m i is calculated according to a linear function f;

[0068] (3-2) The group user π generates an integrity auditing label anonymously for the data block m i , and calculates the event signature x π is the private key of the group user π, two random numbers are selected, and is calculated, wherein r i is the index of the data block m i ; and verification auxiliary information is calculated, and the data block m iIntegrity audit tag of completeness

[0069] (3-3) After the group user generates the integrity proof tag of completeness for each data block, the group file F generates the integrity audit tag set Tag = (tag i ) 1≤i≤n ; The cloud storage server and the third-party auditor can trace the user identity according to the integrity audit tag, and verify whether different integrity audit tags are generated by the same group user;

[0070] (4) The third-party auditor constructs a hash chain table and calculates the data block index r1, r n ; Initialize the hash chain table node A1 = (N1 = n, head1→r1, tail1→r n}, where N is the number of data blocks stored in the node, head1 is the first data block index stored in the node, and tail1 is the last data block index stored in the node.

[0071] (5) The third-party auditor and the cloud storage server interact to generate data integrity audit results, including the following steps:

[0072] (5-1) The third-party auditor randomly selects a subset I consisting of c elements from the data block set [1, n]; for each c i , select a random number v i , traverse the hash chain table to obtain the index r i ; Randomly select an element a in the finite field Z p ; Calculate H(r i ) = a(H(r i ) + 1), generate a random challenge Q = (H(r i ), i, v i} i∈I ;

[0073] (5-2) The cloud storage server finds the corresponding data block m i and its tag where i ∈ I, and calculates the integrity proof P = (σ, K, Z, X, Y, (μ j} (1≤j≤s) , (τ i} i∈Q ), where:

[0074]

[0075]

[0076] μ j = ∑ i∈Q vi m ij (1≤j≤s),

[0077] (5-3) The third-party auditor proves P = (σ, K, Z, X, Y, (μ) based on the integrity of the evidence. j} (1<j<s) , (τ i} i∈Q ), Challenge Q = (H(r) i ), i, v i} i∈I The event e = H(event) is calculated, and the user group public key set γ is used to verify whether equation (1) holds true.

[0078]

[0079] Calculate the parameters using the verified auxiliary data 'a'. Calculate and verify whether equation (2) holds true:

[0080]

[0081] Only when both equations (1) and (2) are true is the integrity verification result considered correct and the audit result accepted returned; otherwise, the integrity of the cloud storage server data is compromised and the audit result rejected is returned.

[0082] (6) Tracing the identity of group users includes the following steps:

[0083] (6-1) Obtain integrity audit labels tag1 = (t1, ·}, tag2 = (t2, ·}, and verify the validity of integrity audit labels;

[0084] (6-2) Compare whether t1 is equal to t2. If they are equal, then data blocks m1 and m2 were generated by users in the same group, and the verification result is returned as linked. Otherwise, data blocks m1 and m2 were generated by users in different groups, and the verification result is returned as unlinked.

[0085] (7) When group users dynamically modify data, third-party auditors efficiently update the hash chain, including the following steps:

[0086] (7-1) Data Insertion: Insert a data block after point i for group users, and randomly select the data insertion index r′←Z. p The insertion position i, r′ and operation op="insert" are sent to the third-party auditor; the third-party auditor calls Algorithm 1 to obtain the insertion position (j, i) of the data in the hash list. * ), indicating that the data index is located in hash block A. i Inner i* After the block, Algorithm 2 is called to update the hash chain;

[0087] Algorithm 1: Input data position i, output data position (j, i) in the hash chain. * Let the hash list ∏ = (A1, ..., A2) be a chain of hash tables. c}, where A j =(N j head j , tail j Let A be a node in the hash chain. Traverse node A in the hash chain. j , where (1≤j≤c); let i * =i, compare i sequentially * With N j The size of i; if i * >N j Then let i * =i * -N j ; if i * ≤N j Then return (j, i) * End the traversal;

[0088] Algorithm 2: Input (j, i) * Let r′ be a hash list ∏, and output the updated hash list ∏′. Let the hash list ∏ = (A1, ..., A2). c}, where A j =(N j head j , tail j} represents a node in the hash chain. If i * =N j Let A j =(N j =N j +1, head j →head j , tail1→r′}; if i * ≠N j Then a new node A is generated. j+1 =(N j+1 =N j -i * head j+1 →head j +i * , tail j+1 →tail j Let A j =(N j =i * +1, head j →headj , tail1→r′} ;

[0089] (7-2) Data deletion: group users delete data block at i, send i and operation op= "delete" to the third-party auditor, where i is the deletion position; the third-party auditor calls algorithm 1 to obtain the deletion position (j, i * ) of the data in the hash chain table, and then calls algorithm 3 to update the hash chain table;

[0090] Algorithm 3: input (j, i * ), r', hash chain table∏, output updated hash chain table∏'; let hash chain table∏=(A1,..., An c}, where An j =(N j , head j , tail j} is a node in the hash chain table. If i * =N j , let A j =(N j =N j -1, head j →head j , tail1→head j +(i * -2)}; if i * ≠N j , generate a new node A j+1 =(N j+1 =N j -i * , head j+1 →head j +i * , tail j+1 →tail j}, let A j ={N j =i * -1, head j →head j , tail1→head j +(i * -2)}.

[0091] (7-3) Data modification: group users modify data block m i to m i ', generate a corresponding tag tag i ', upload m i ' and tag i ' to the cloud storage server.

[0092] The above examples are only used to illustrate the technical solutions of the present application but not to limit the present application, and the ordinary skilled in the art can modify or equivalently replace the technical solutions of the present application without departing from the spirit and scope of the present application, and the protection scope of the present application should be subject to the claims.

Claims

1. A group-oriented efficient dynamic data integrity auditing method, characterized in that, The method comprises the following steps: Step 1: the system generates global public parameters param based on a security parameter λ, selects a multiplicative cyclic group G of a safe prime number p, randomly selects two independent generators g and h, selects a hash function H into the G group, and sets system parameters param = {G, p, g, h, H}; Step 2: Group users generate a key and public key according to system parameters, select two random elements (x j ,y j )←Z p , let the private key sk j =(x j ,y j ), calculate the public key Step 3: the group user generates an integrity audit label with anonymity; Step 4: The third-party auditor constructs a hash chain table, calculates the data block index r1, r n ; initializes the hash chain table node A1 = {N1 = n, head1→r1, tail1→r n}, where N is the number of data blocks stored by the node, head1 is the first data block index stored by the node, and tail1 is the last data block index stored by the node; Step 5: the third-party auditor interacts with the cloud storage server to generate a data integrity audit result; Step 6: the group user dynamically modifies the data, and the third-party auditor efficiently updates the hash chain table.

2. The group-oriented efficient dynamic data integrity auditing method according to claim 1, characterized in that, The step 3 comprises the following steps: Step 31: Group file F is divided into n data blocks m of the same size i , and m i is further divided into s data blocks m ij of the same size, where (1≤i≤n, 1≤j≤s), where s is the number of group users, and the index information r i of data block m i is calculated according to a linear function f Step 32: Group user π signs data block m i Anonymously generates integrity audit tag, computes event signature x π is the private key of group user π, selects two random numbers Computes where r i is the index of data block m i Computes verification auxiliary information Generates integrity audit tag of data block m i ​ Step 33: After the group user generates the integrity proof tags for each data block anonymously, the group file F integrity audit tag set Tag = {tag i} 1≤i≤n ; the cloud storage server and the third-party auditor can trace the user identity according to the integrity audit tags, and verify whether different integrity audit tags are generated by the same group user.

3. The group-oriented efficient dynamic data integrity auditing method according to claim 2, characterized in that, The step 33 comprises the following steps: Step 331: obtain the integrity audit labels tag1 = {t1, ·} and tag2 = {t2, ·}, and verify the validity of the integrity audit labels; Step 332: compare t1 with t2, if they are equal, the data blocks m1 and m2 are generated by the same group user, and a verification result linked is returned, otherwise the data blocks m1 and m2 are generated by different group users, and a verification result unlinked is returned.

4. The group-oriented efficient dynamic data integrity auditing method according to claim 1, characterized in that, The step 5 comprises the following steps: Step 51: the third-party auditor randomly selects a subset I consisting of c elements from the data block set [1, n]; for each c in the challenge set i , select a random number v i , traverse the hash chain table to obtain the index r i ; randomly select an element a in the finite field Z p ; calculate H(r i ) = a(H(r i ) + 1) to generate a random challenge Q = {H(r i ), i, v i} i∈I ; Step 52: The cloud storage server looks up the corresponding data block m according to the challenge set Q i , and its label where i∈I, computes the integrity proof P=(σ, K, Z, X, Y, {μ j} (1≤j≤s) , {τ i} i∈Q ), where: Step 53: The third party auditor computes the verification equation (1) using the integrity proof P = (σ, K, Z, X, Y, {μ j} (1<j<s)}, τ i} i∈Q ), challenge Q = {H(r i ), i, v i} i∈I , event e = H(event), and group user public key set γ. By means of the verified auxiliary data a, the parameter Calculate whether the verification equation (2) holds: Only when the equation (1) and the equation (2) are established at the same time, a correct integrity verification result is considered to be obtained, and an audit result accept is returned, otherwise the data integrity of the cloud storage server is destroyed, and an audit result reject is returned.

5. The group-oriented efficient dynamic data integrity auditing method according to claim 1, characterized in that, The step 6 comprises the following steps: Step 61: Data insertion: Group users insert data block after i, randomly select insertion data index r'←Z p Send insertion position i, r' and operation op="insert" to third-party auditor; third-party auditor calls algorithm 1 to obtain the insertion position (j, i * ) of data in the hash chain table, which represents that the data index is located after the i j th block in the hash block A * Call algorithm 2 to update the hash chain table; Step 62: Data deletion: group user deletes data block at i, sends i and operation op = "delete" to third-party auditor, where i is the deletion position; the third-party auditor calls algorithm 1 to obtain the deletion position (j, i * ) of the data in the hash chain table, and then calls algorithm 3 to update the hash chain table; Step 63: Data Modification: Group users modify data block m i to m i ' and generate corresponding label tag i ', upload m i ', tag i ' to cloud storage server.

6. The group-oriented efficient dynamic data integrity auditing method according to claim 5, characterized in that, In the step 6, the specific steps of the algorithm 1, the algorithm 2 and the algorithm 3 are as follows: In the step 6, the specific steps of the algorithm 1, the algorithm 2 and the algorithm 3 are as follows: (1) Algorithm 1: Input data position i, output data position (j, i) in the hash chain. * Let the hash list Π = {A1, ..., A} be a chain of hash tables. c }, where A j ={N j ,head j ,tail j } represents a node in the hash chain; traverse node A in the hash chain. j , where (1≤j≤c); let i * =i, compare i sequentially * With N j The size of i; if i * >N j Then let i * =i * -N j ; if i * ≤N j Then return (j, i * End the traversal; (2) Algorithm 2: input (j, i * ), r', hash list Π, output updated hash list Π'; let hash list Π = {A1,..., An} where An = {Nn, headn, tailn} is a node in hash list; if i c = Nn, let An = {Nn = Nn + 1, headn→headn+1, tailn→r'}; if i j ≠ Nn, generate a new node An = {Nn = Nn - i j , headn→headn+i j , tailn→tailn-i j}, let An = {Ni = i * + 1, headn→headn+1, tailn→r'}. j j j j j j * j j+1 j+1 j * j+1 j * j+1 j j j * j j ​​​​​​​​​​​​​​​​​​​​​​ (3) Algorithm 3: input (j, i * ), r', hash list Π, output updated hash list Π'; let hash list Π = {A1,..., An} where An = {N, head, tail} be nodes in hash list; if i c = N, let An = {N j = N j - 1, head j → head j , tail1→ head * +(i j - 2)}; if i j ≠ N, generate new node An = {N j = N j - i j , head j → head j +i * , tail * → tail j}, let An = {N j+1 = N j+1 - 1, head j → head * , tail1→ head j+1 +(i j - 2)}. * j+1 j j j * j j j * ​​​​​​​​​​

Images