Optimizing data retrieval for enhanced data integrity verification in cloud environments

1.1 Research contribution

The proposed study presents a comprehensive contribution to the field of data integrity verification in cloud environments. The key contributions are highlighted as follows:

1. A novel system for verifying the integrity of data stored in the cloud environment is devised. This system is a significant improvement over the existing methods and enhances the overall reliability of cloud storage systems.

2. In the proposed approach, the BST data structure for data insertion, deletion, updation, and auditing has been utilized in the cloud environment. This leads to improved performance and efficiency in managing the data stored in the cloud.

3. The work described in this article has been thoroughly analyzed for various security threats, and countermeasures have been proposed to mitigate these risks. This ensures that the data stored in the cloud is protected against unauthorized access, tampering, and other security threats.

4. To confirm the effectiveness of the proposed method, a statistical analysis is conducted, which shows that the proposed approach outperforms the existing works in terms of data integrity verification in the cloud environment.

1.2 Organization of this article

Section 2 reviews relevant literature on data auditing protocols, summarizing prior research efforts aimed at enhancing data storage and protection on remote servers. In Section 3, the key research contributions are highlighted showcasing novel approaches, innovative techniques, and insights addressing existing literature gaps to provide new perspectives for future work. Section 4 provides essential background knowledge for implementing the proposed approach, explaining preliminary concepts and secure assumptions to establish a strong foundation for understanding later technical details. Section 5 thoroughly examines the proposed method, breaking it down into parts covering system design aspects, workflow, architecture, and visual aids to elucidate component interactions. It offers a comprehensive understanding of how the method addresses challenges and requirements outlined in Section 1. Section 6 provides the assessment of security threats to the proposed system. It also offers a detailed analysis of mitigation measures emphasizing the importance of the robust security for data protection and system integrity. Section 7 compares the components of the proposed model with other existing models, highlighting the advantages and superiority. Section 8 offers a comprehensive conclusion, summarizing findings, strengths, and future potential of the proposed method. It also identifies areas for improvement and extension.

2.1 Conventional schemes

Ateniese et al. [9] introduced the concept of the “provable data protocol (PDP),” which allows a client to verify that the original data are stored on an untrusted server without retrieving it. On the other hand, Juels et al. [10] proposed a work called “proof of retrievability (PoR),” which not only verifies the integrity of the data but also ensures that it can be retrieved from the cloud through an error-correcting method.

Liu and Zic [11] introduced a PoR scheme built on homomorphic encryption. The PoR scheme allows for the retrieval of homomorphically encrypted data through the generation of probabilistic and homomorphic message authenticators, allowing for direct handling of the encrypted data by the cloud. The integrity of outsourced computations can also be verified by the PoR scheme. The researchers developed a prototype to test the scheme; however, no comparison was made to any existing work.

2.2 Schemes based on Merkle hash tree (MHT)

Wang et al. [4] proposed a protocol that balances both public auditing and dynamic information management. It uses a combination of Boneh–Lynn–Shacham (BLS) [12] signatures and MHT. While this protocol ensures data integrity, it falls short in providing privacy for information stored in remote storage.

Luo [13] improved the prior privacy-preserving model and proposed an effective integrity check technique of cloud data based on signature (BLS) that secures both public access and data privacy.

Du et al. [14] proposed a cost-effective solution for file storage that combines proof of ownership and retrievability. The files are encoded using erasure coding, and the use of Merkle trees and homomorphic verifiable tags reduces computation costs, particularly for large files. However, this approach increases storage costs.

2.3 Schemes with third-party auditor (TPA)

Kwon et al. [15] presented a review system for dynamic distributed information in cloud storage, which involves a third-party reviewer and a record table. The uploader must split the information into chunks, label them, and direct them to the clients for sharing. The uploader can also confirm the information with the third-party inspector. However, this approach incurs high communication costs due to the frequent exchange of messages between clients and data uploaders, and this also results in increased storage expenses for the third-party inspector. Every time the information is updated, the record table must also be updated by the third-party inspector.

More and Chaudhari [16] presented a strategy in which information is encrypted at the owner’s side by dividing it into chunks and applying scrambling, producing hash labels for each chunk. The hash labels are then used to generate a signature for the specific owner. However, this approach requires more time and involves multiple steps on the owner’s side. The proposed scheme also involves verification by a third-party analyst, who must recreate the steps performed by the owner to cross-verify the digital signature, adding an additional layer of security.

The aim of Shah et al. [17] was to develop and introduce a TPA in cloud storage to enhance security and maintain data integrity. The TPA is noted for its adaptability and ease of use. The authors claimed that the TPA can effectively perform simultaneous reviews for multiple clients and verify the integrity of information stored in the cloud. The study suggests that the proposed protocol is secure and well structured; however, the computational cost needed for implementation is not explicitly stated in this article.

2.4 Schemes without TPA

Yuan et al. in their study [18] proposed a strategy to enhance integrity of information sharing activities in the cloud. This strategy takes into account various important aspects such as client disavowal, open examination, multi-user adjustment, increased error detection probability, and efficient computational and communication auditing execution. The proposed approach is designed to resist client impersonation attacks and enables multiple clients to collaborate on data without the risk of impersonation or data theft or modification. However, the computational cost of implementing the proposed protocol is not specified in this article.

Zargad et al. [19] presented a dynamic encryption approach for cloud storage without the use of a neutral reviewer. According to the proposed method, the judgment of the information is lost when it is outsourced to the cloud. Whenever there is a security threat, an encryption method is applied based on the type and size of the information stored. The method employs an executor, such as a proxy server, to handle incorrect additions or alterations, but it lacks a proper mechanism for key management, which is an important aspect of secure information storage in the cloud.

Kaaniche in her dissertation [20] proposed a design for ensuring the integrity of information in a public network sharing setup. She proposed a system called “cloudasec” that verifies information ownership using set homomorphic verification and zero-knowledge proof techniques. Although the proposal highlights the importance of remote information checks in a cloud environment, it lacks a comprehensive overview of dynamic information corroborations.

Li et al. [21] presented a secure and lightweight information sharing scheme for mobile computing. They used ciphertext policy-attribute-based encryption (CP-ABE) in a cloud environment as an access control technique. The implementation was based on the access control tree concept, and the team used the description fields to implement the lazy revocation method. The study reported that the overhead or processing time is reduced on mobile devices when information is distributed in the mobile cloud environment. However, the computational cost required to implement the protocol is not clearly stated.

Anisetti et al. in their work [22] aimed to provide a persistent cloud service certification framework that would meet non-functional requirements as defined by a certification model and specialist. The framework relies on a chain of trust, established through the comparison of the requirements and models. However, the authors do not address the computational and communication cost required to implement the certification scheme.

Mrinal et al. [23] proposed a technique to maintain the authenticity of information during transmission by hiding the information behind an image. The approach focuses on ensuring the integrity of the information, but it does not provide a solution for the confidentiality of the information.

Sun et al. [24] presented an open data integrity verification scheme that uses cryptographic indistinguishability obfuscation. The scheme aims to hide users’ secret data from the cloud server by embedding it into a scrambled program. However, the computational cost required to implement this scheme is not mentioned in the study.

Wang and Di [25] presented a multi-agent-based cloud storage system that implements a multi-copy data integrity check method. They utilized the bi-linear mapping method to generate the keys, and a multi-branch tree for authentication was proposed to perform signing, validation, and confirmation through multi-copy data signatures. The allocation of resources and workflow was based on quality of service (QoS) and represented through a directed acyclic graph (DAG). The jobs were scheduled based on the QoS preference settings.

Ganesh and Manikandan [26] presented a scheme for verifying the remote information stored in public clouds, specifically designed for mobile users. They claimed that the communication and computation overhead was reduced compared to previous works. The authentication process was carried out during the auditing, modification, deletion, and insertion of blocks.

Chidambaram et al. [27] proposed a scheme for secure storage of customer data in the cloud. They utilized the Rivest, Shamir, Adleman (RSA) algorithm and digital fingerprint generated using the MD5 hash function. The authors claimed that data encrypted with the RSA algorithm cannot be modified by a third party.

Zhong et al. [28] developed an information-theoretic safe proof of ownership mechanism for file rating. The K-means technique was integrated with file rating, and the use of random seed technology and pre-calculation approach was proposed to provide a secure and fast proof of ownership mechanism.

2.5 Schemes with other structures

Canto et al. [29] presented the methods for creating secure key generators for code-based post-quantum cryptosystems on field programmable gate arrays (FPGA) platforms. It focuses on ensuring reliable key generation, critical for system security. The study discusses optimizations leveraging FPGA parallelism. However, it may not extensively cover potential limitations, such as resource constraints or performance trade-offs, inherent in FPGA-based implementations.

Chen et al. [30] put forth a groundbreaking public auditing protocol based on the adjacency-hash table. This new protocol was designed to be more efficient in terms of dynamic auditing and data updating when compared to the existing methods available at that time. The authors claimed that this protocol outperformed the state of the art methods in these aspects.

Koziel et al. [31] discussed a highly efficient implementation of the supersingular isogeny Diffie–Hellman key exchange protocol on advanced RISC machine (ARM) processors. It focuses on optimizing the protocol’s performance on ARM-based devices, which are commonly used in mobile and embedded systems. The study likely covers techniques and optimizations to leverage ARM’s neon technology for enhanced performance. However, a potential limitation of this work could be its applicability to specific ARM architectures or limitations in scalability to larger systems beyond mobile or embedded devices.

Kermani et al. [32] explored integrating security research and education for new medical devices. It addresses interdisciplinary strategies for tackling security concerns. However, a limitation could be the complexity of merging diverse expertise, such as medical, engineering, and cybersecurity, which might hinder comprehensive security solutions, and on the other hand, Kermani [33] focused on detecting faults in very large scale integration implementations of advanced encryption standard (AES) encryption. It presents schemes to mitigate faults affecting AES’ performance, but a limitation may arise from the trade-offs between fault detection accuracy and overhead. More robust detection methods could demand additional hardware resources, impacting efficiency in terms of performance or area.

Yan [34] proposed a secure and efficient data exchange solution for dynamic user groups. To ensure user identification tracking and handle the addition and removal of dynamic users, Yan introduced the concept of a rights distribution center (RDC). The RDC role was designed to protect the privacy of user identities during a third-party audit of data integrity, thereby increasing the fairness of the audit and establishing a new approach to verifying the integrity of shared cloud data.

Chandel et al. [35] conducted a study comparing the time complexity of RSA and elliptic curve cryptography (ECC) algorithms for encrypting and decrypting data. They found that the time required for RSA grows logarithmically as the amount of data to be encrypted increases, while the time complexity of ECC remains relatively constant.

Niasar et al. [36] focused on enhancing the performance of ECC specifically for Curve448. It discusses optimizations in hardware architectures or algorithms to speed up ECC operations on Curve448, which is crucial for secure communications protocols. However, previous studies [37–40] explored dependable architectures for finite field multipliers, emphasizing their implementation using cyclic codes on FPGA platforms. These architectures are vital in both classic and post-quantum cryptography systems. All of these articles contribute to improving the efficiency, reliability, and security of cryptographic operations, addressing key challenges in modern cryptographic implementations.

Mozaffari-Kermani et al. [41] discussed crucial aspects such as protecting sensitive medical data, securing medical devices, and fortifying healthcare infrastructure against cyber threats. The collection aims to underscore the growing significance of security in biomedical contexts and offers insights into current challenges and potential solutions within this dynamic field, whereas Karam et al. [42] discussed the significance of hands-on learning in hardware security, especially during a time when traditional in-person education is limited. However, a limitation of the study is that it may not yet have comprehensive results or evaluations due to its work-in-progress nature. Nonetheless, it offers valuable insights into innovative strategies for addressing educational challenges in hardware security during the pandemic.

The field of cloud data integrity has seen a significant amount of research over the years, resulting in the proposal of various methods and works aimed at ensuring the accuracy and reliability of data stored in the cloud. However, many of these works only focused on verifying the integrity of static data, while others relied on TPAs to carry out the check. This means that the owner or user of the data must first request the integrity check, which then triggers the TPA to conduct the audit. This process also involves a significant amount of communication between the TPA and the owner to verify the ownership of the data and retrieve it, adding to the overall cost of the data integrity check. The BST-based model presented in this article aims to enhance the integrity check process while simultaneously reducing communication costs.

4.1 Architecture of BST-based model

In the proposed BST-based model there are three primary entities: DO, CSP, and auditor. Figure 2 depicts the overall architecture of the BST-based model with the functions of each primary entity.

• CSP: The CSP is a remote storage unit whose only responsibility is to store the received files. It provides the response when it is challenged by the auditor in reference to a file. When the file is requested by the auditor, it sends the corresponding file to the auditor. The BST model begins with CSP launching its storage server, as shown in Figure 3, and goes to listening mode.

• DO: This module represents the user side of the model. It manages all the invocation of input-output operations for the user, including insertion, deletion, update, and audit. Additionally, the DO will encrypt a new file using its private key generated using elliptic curve encryption technique before calculating the SHA-2 hash.

• Auditor: This module is the system that performs the auditing process. It acts as a mediator and interaction point between the DO and CSP. It also does most of the work in the BST model. It manages the insertion, deletion, and modification of files stored in CSP. It records the user’s user ID (UID), IP address, and password for authentication purposes. It further maintains the file metadata for each user, including hash, version number, and file ID (FID). The storage of these data is performed using BST of BST method, which is explained in Section 4.2. This module initializes the BST by pulling data from the database and starts the server to go to the listening mode as shown in Figure 4.

• If a user submits an audit request, the auditor sends a challenge to the CSP, which in turn sends the response of the existence of the file and then sends the requested file to the auditor. The auditor in turn calculates the SHA-2 hash and compares it with the hash stored in the system. Based on the result of this comparison, the auditor informs the user whether the file is safe.

Figure 2

Architecture of the BST-based model.

Figure 3

Workflow of CSP.

Figure 4

Workflow of auditor.

4.2 Overview of BST of BST structure

This structure is the core of auditor module. As the name indicates, there are two BSTs that are connected such that the first tree us a user tree where each node of represents an individual user. The user nodes include the user’s UID and IP address. It also has three other pointers, of which the first two are conventional left and right child pointers, while the third is a reference to the user’s file tree as indicated by the dotted arrow in Figure 5.

Figure 5

User tree and single BST node.

Algorithm 1 shows the steps involved in generating the BST of BST structure whenever there is a new user joining the system.

Each file uploaded to the CSP is referenced via the file tree, as shown in Figure 6. Each node represents a file and holds its FID, hash, and version number. It also contains two conventional pointers to the node’s left and right children. The UIDs and FIDs determine the structure of the trees.

Figure 6

File tree and single file node.

Algorithm 2 depicts the creation of the file BST after searching the user BST for the user

To insert a new node, an ID comparison is performed, and traversal through the tree leads to the pointer where the new node must be connected. If the node being deleted is a leaf node, straightforward deletion will occur. If the child on the right does not exist, the child on the left will take its place. If the child to the left does not exist, the child to the immediate right will take its place. In all other circumstances, the node with the least value on the right child will replace the current node, and for a file update, the hash value and version of the relevant node will be replaced with the new values. Once the CSP and auditor start and go to the listening mode, the DO attempts to connect with the auditor server, as shown in Figure 7.

Figure 7

Workflow of DO.

4.3 Process framework

After a link or a session has been established, the auditor inquires whether the user is new. If the user responds affirmatively, auditor provides the user with a UID and password; otherwise, it requests the UID and password from the user. The auditor then compares the UID and password up to three times and blocks the connection from the incoming IP if the comparison fails. If the connection is successful, the user can perform the following operations or requests.

4.3.4 Audit

During the auditing process, the DO will transmit the FID to be audited, while the auditor will request the file from the CSP using the UID and the FID. In the process, the generation of the challenge involves creating a set of file numbers to be verified, denoted as C = fid, 1 ≤ c , c ≤ n , and selecting a random file number from the set, denoted as S = s i , i ∈ C . Additionally, a random number ρ ∈ Z is generated, and g is raised to the power of ρ , denoted as ξ = g ρ . The cloud auditor then calculates y raised to the power of ρ , denoted as η = y ρ , for use in verification. The challenge is then sent to the CSP, who generates a proof and returns the result to the cloud auditor for verification.

Once the auditor obtains the file from the CSP, it will compute the following equation to verify the proof sent from CSP:

(3) TP = λ ρ . e ( u H ( v i ‖ t i ) . s i , v M , ρ ) .

If Equation (3) is proven to be correct, then the data integrity verification process is considered to be succeeded. The verification process is in par with the file’s SHA-2 hash and compare it to the hash contained in the file node in the BST. If the calculated hash matches the hash stored in the BST, then the file has not been altered since it was stored in the cloud. On the other hand, if the calculated hash does not match the hash stored in the BST, then it indicates that the file has been modified since it was last stored in the cloud, and appropriate measures can be taken to address the issue. Figure 8 describes the auditing process followed in the proposed work. Table 1 summarizes the steps involved in the auditing process.

Figure 8

Steps involved in auditing process.

Table 1

Steps involved in auditing process

O: E p s k (R)

U 1 → CA: Request R Fid

CA → CSP: Challenge(Fid)

CSP → CA:Proof(Fid)

CSP → CA: E p s k (R)

CA: D p s u ( E p s k (R))

CA: Generatehash(R)

CA: Verifyhash(R)

CA → U 1 : E p s k (R) with integrity verification result

This approach of comparing hash values ensures the integrity of the file and is a widely adopted practice for file verification in various domains. By following this process, the auditor can ensure that the data has not been tampered with, and the DO can be assured that their data remains secure and unaltered in the cloud.

On the other hand, after receiving the challenge from the cloud auditor, the CSP generates a response proof, consisting of three parts: tag proof, file proof, and auxiliary auditing proof. The tag proof, given by the equation

(4) TP = ∏ i ∈ C e ( σ i , ρ ) s i ,

is computed by taking the product of the pairing between the signature σ i and the random number ρ , raised to the power of the corresponding element s i in set S . The file proof, given by the equation

(5) M = ∑ i ∈ C m . s i + r ,

is calculated by taking the sum of the product between the file m and the element s i , for each file i in set C , and adding a random padding/mask r used to protect the data privacy. Finally, the auxiliary proof is derived using the following equation:

(6) λ = e ( v , y ) − r ,

where v is a verification key provided by the cloud auditor, and y is the PK of the CSP. Once these values are computed, the CSP sends the tuple ⟨ TP , M , λ ⟩ to the cloud auditor for verification.

5.1 Threat analysis and mitigation

This section enumerates a comprehensive list of potential threats that have been identified as potential vulnerabilities. Additionally, it outlines corresponding mitigation methods for each of these threats. To analyze the possible threats, Microsoft threat modeling tool has been used. Figure 9 shows the generic threat model that has been used to identify the possible threats.

Figure 9

Generic threat model for BST-based model.

As described in the Section 4.1, there are three primitive modules in the BST-based model. The DO encrypts the data, generates the hash of the encrypted data, and sends the files to the auditor. Once the auditor generates the file number, it is sent back to the DO. Auditor has BST storage in it which stores various metadata related to the user and the respective files of the users. It stores and fetches these data to and from the BST of BST whenever the need arises. The CSP module, in turn, stores the data that the auditor sends. When the auditor sends the challenge to the CSP, it sends the necessary response back to the auditor.

Table 2 summarizes the threats that were identified along with the mitigation steps that were taken as a countermeasure to overcome those threats.

Table 3 compares the BST-based structure doubly linked list based index table (DLIT) structure with index-based method in terms of whether the methods handle the listed vulnerabilities or not.

Table 4 shows a comparison of communication cost in terms of the various operations that are involved in various state of the arts.

5.2 Scheme analysis

This section confidently asserts the effectiveness of the BST-based method against forging attacks and confirms its correctness.

Correctness: The verification process of the owner’s identity as a rightful cloud user is carried out with utmost confidence via the signature scheme. Once the CSPs follow the appropriate standards, passing the auditing process becomes a guaranteed success. The file’s number, version number, name, and timestamp are all utilized to create a signature that is protected by the BLS signature against any potential tampering

When data are sent from the auditor to the CSP for verification, it is encrypted using a secret key to produce E p s k . These encrypted data contain the PK, message digest, file identifier, version number, and timestamp. If the data are modified by an adversary, the version number and message digest will change, resulting in incorrect encrypted data (E p s k * ). As a result, when the auditor receives tampered data from the CSP and performs the check, it will fail if either the message digest does not match or the timestamp is different.

To verify the accuracy of the CSP’s response, the lambda value of the response is analyzed. This value is denoted as λ ρ . e ( u H ( v i ‖ t i ) . s i . v M , ρ ) = TP , where TP is the tag proof. If the auxiliary proof is incorrect, the verification formula (4) will not hold. The BLS signature scheme ensures that the tag-proof TP cannot be forged.

Resistance to forging attacks: The block proof M is proven to be unforgeable, as demonstrated below. Let us assume that a false proof is submitted to the cloud auditor by the CSP (TP, M*, λ ), where

If the CSP successfully passes the verification, the following equation holds for valid proofs:

This equation readily refutes the presumption made in the false proof, proving that forging attacks are effectively counteracted. Furthermore, as Shen et al. [7] have explained, replay and replacing attacks can be effectively blocked or halted.

5.3 Performance analysis

5.3.1 RSA vs ECC

The Table 5 demonstrates that ECC provides better security than RSA, even with significantly smaller key sizes.

Table 5

RSA vs ECC

Security (in Bits)	RSA key length required	ECC key length required
80	1,024	160–223
112	2,048	224–255
128	3,072	256–383
192	7,680	384–511
256	15,360	512+

To demonstrate that it is a faster encryption system, both encryption systems were compared by encrypting files with 300 byte size increments in each iteration, recording the time required to complete them. The results were charted and two cases were presented: one with the same degree of security as shown in Figure 10 and another with the same key size as shown in Figure 11.

Figure 10

RSA 3072 vs ECC 256.

Figure 11

RSA 521 vs ECC 521.

The graphs demonstrate that ECC surpasses RSA in every category, including security and performance.

5.3.2 BST of BST vs DLIT

This section details the space complexity and time complexity concerning the BST-based method and DLIT method.

5.3.2.1 Space complexity

The space utilization of both algorithms is directly proportional to the number of nodes present in the data structure. This is because the creation of a new node requires an allocation of memory of the size of one node class every time it is generated. As a result, at any given moment, the stack allocation of both data structures will be equivalent to the number of nodes present. Therefore, the space complexity of both algorithms can be represented by the expression O ( n ) , where n signifies the number of nodes in the data structure.

5.3.2.2 Time complexity

The algorithm for BST implements a divide-and-conquer strategy, where both the tree and search set are iteratively halved. This results in an average time complexity of O ( log n ) . To locate a specific file node, the process involves traversing the user tree to find the corresponding user node, followed by traversing the file tree to access the desired file node. As a result of this two-step process, the overall average time complexity of the BST algorithm is estimated to be O ( log n * log m ) , where n represents the number of user nodes and m represents the number of file nodes.

A linked list is a data structure in which each node is connected to the next node using a pointer. To locate a specific node in a linked list, one has to traverse each subsequent node until the desired node is found. This traversal process results in a time complexity of O ( n ) , where n is the number of nodes in the list.

When searching for a file node, the process becomes even more time-consuming. The file node must be found by first browsing through a linked list of user nodes and then traversing the list of file nodes. This results in a time complexity of O ( n 2 ) .

As depicted in Figure 12, the BST-based method performs better than the index-based linked list method during the auditing process. The BST method has a faster time complexity, making it more efficient in this scenario.

Figure 12

Comparison of index table method and BST method in seconds for auditing.

5.4 Statistical analysis

The efficacy of the proposed methods can be scientifically evaluated through hypothesis testing, specifically analysis of variance (ANOVA). Both methods were implemented using a similar system setup and configuration to ensure fair comparison.

The hypothesis for the validation is defined as follows:

H 0 states that there is no significant difference between the index table method and the BST method,

H 1 states that there is a significant difference between the two methods.

To determine which hypothesis holds true, ANOVA was performed using the observed values for various block-sized files, as presented in Table 6. These observations were made in terms of milliseconds for the auditing process. The results of ANOVA will determine if there is a significant difference in performance between the two proposed methods.

Table 7 provides the details about the various factors that are calculated.

Table 8 details about the prerequisite value calculations for the F-calculation of ANOVA.

From the prerequisite values calculated in Table 8, the F-ratio is given by

Therefore, F calculated is 20.34781. This value is then verified with the t-table where

Comparing the calculated and tabulated value of t-statistic:

The results of Equations (1) and (2) were substituted into Equation (3), revealing that the calculated value of F ( F calculated ) was higher than the tabulated value of F ( F tabulated ). This indicates that the calculated value falls within the rejection region; hence, the results reject the null hypothesis with the significance level that falls below 5%. This rejection of the null hypothesis suggests that there is a significant improvement in the execution time of the data integrity check process when using the BST method.

In other words, the analysis demonstrates that the BST method leads to a marked reduction in the execution time required to perform the data integrity check process, compared to traditional methods. This result supports the effectiveness of the BST method in improving the efficiency of data integrity checks in cloud environments.

6.1 Conclusion

In conclusion, the proposed study has focused on optimizing data retrieval processes to bolster data integrity verification in cloud environments. With the exponential growth of global data transfer, cloud data storage has become a pivotal solution, necessitating robust mechanisms for maintaining data integrity.

The proposed methodology, centered around a data integrity auditor framework, emphasizes efficient data retrieval while ensuring enhanced data integrity verification. By leveraging a BST for streamlined metadata management and employing ECC for secure data encryption, our approach optimizes data retrieval processes crucial for integrity verification.

Our comparative analysis against established methods such RSA and index table-based DLIT showcases the efficiency and security benefits of our proposed solution. These findings underscore the significance of optimizing data retrieval mechanisms to fortify data integrity verification in cloud environments.

Furthermore, it contributes to the ongoing discourse on cloud data management by providing a comprehensive approach that addresses critical challenges in cloud-based data storage and security. By optimizing data retrieval processes, we not only enhance data integrity verification but also pave the way for more efficient and secure cloud data management practices.

Overall, the work underscores the importance of considering data retrieval optimization as a key aspect of ensuring data integrity in cloud environments, highlighting avenues for further research and development in this domain.

6.2 Future scope

This article provides a foundation for future work that can be done on this model and system such as:

• Enhancing the security measures to provide an even higher level of protection using Curve448 or Ed448.

• Enhancing the security measures of the hardwares used in the system by testing for SIKE, Kyber on Cortex M4 or ARM processors.

• Various fault detection techniques or error detection methods for block ciphers such as Camilla, Midori cipher, Qualcomm ARM Authenticator, or a stream cipher such as WAGE.