Robustness in the Salus Scalable Block Store

Total Page:16

File Type:pdf, Size:1020Kb

Robustness in the Salus Scalable Block Store Robustness in the Salus scalable block store Yang Wang, Manos Kapritsos, Zuocheng Ren, Prince Mahajan, Jeevitha Kirubanandam, Lorenzo Alvisi, and Mike Dahlin The University of Texas at Austin Abstract: This paper describes Salus, a block store that guarantees despite a wide range of server failures (in- seeks to maximize simultaneously both scalability and cluding memory corruptions, disk corruptions, firmware robustness. Salus provides strong end-to-end correctness bugs, etc), and leverages an architecture similar to scal- guarantees for read operations, strict ordering guarantees able key-value stores like Bigtable [14] and HBase [6] to- for write operations, and strong durability and availabili- wards scaling these guarantees to thousands of machines ty guarantees despite a wide range of server failures (in- and tens of thousands of disks. cluding memory corruptions, disk corruptions, firmware Achieving this unprecedented combination of robust- bugs, etc.). Such increased protection does not come ness and scalability presents several challenges. at the cost of scalability or performance: indeed, Salus First, to build a high-performance block store from often actually outperforms HBase (the codebase from low-performance disks, Salus must be able to write d- which Salus descends). For example, Salus’ active repli- ifferent sets of updates to multiple disks in parallel. Par- cation allows it to halve network bandwidth while in- allelism, however, can threaten the basic consistency re- creasing aggregate write throughput by a factor of 1.74 quirement of a block store, as “later” writes may survive compared to HBase in a well-provisioned system. a crash, while “earlier” ones are lost. Second, aiming for efficiency and high availability at 1 Introduction low cost can have unintended consequences on robust- The primary directive of storage—not to lose data—is ness by introducing single points of failure. For exam- hard to carry out: disks and storage sub-systems can fail ple, in order to maximize throughput and availability for in unpredictable ways [7, 8, 18, 23, 34, 37], and so can the reads while minimizing latency and cost, scalable stor- CPUs and memories of the nodes that are responsible for age systems execute read requests at just one replica. If accessing the data [33, 38]. Concerns about robustness that replica experiences a commission failure that causes become even more pressing in cloud storage systems, it to generate erroneous state or output, the data returned which appear to their clients as black boxes even as their to the client could be incorrect. Similarly, to reduce cost larger size and complexity create greater opportunities and for ease of design, many systems that replicate their for error and corruption. storage layer for fault tolerance (such as HBase) leave This paper describes the design and implementation unreplicated the computation nodes that can modify the of Salus,1 a scalable block store in the spirit of Ama- state of that layer: hence, a memory error or an errant zon’s Elastic Block Store (EBS) [1]: a user can request PUT at a single HBase region server can irrevocably and storage space from the service provider, mount it like a undetectably corrupt data (see §5.1). local disk, and run applications upon it, while the service Third, additional robustness should ideally not result provider replicates data for durability and availability. in higher replication cost. For example, in a perfec- What makes Salus unique is its dual focus on scala- t world Salus’ ability to tolerate commission failures bility and robustness. Some recent systems have provid- would not require any more data replication than a scal- ed end-to-end correctness guarantees on distributed stor- able key-value store such as HBase already employs to age despite arbitrary node failures [13, 16, 31], but these ensure durability despite omission failures. systems are not scalable—they require each correct node To address these challenges Salus introduces three to process at least a majority of updates. Conversely, s- novel ideas: pipelined commit, active storage, and scal- calable distributed storage systems [3, 4, 6, 11, 14, 20, 25, able end-to-end verification. 30, 43] typically protect some subsystems like disk stor- Pipelined commit. Salus’ new pipelined commit pro- age with redundant data and checksums, but fail to pro- tocol allows writes to proceed in parallel at multiple tect the entire path from client PUT to client GET, leaving disks but, by tracking the necessary dependency infor- them vulnerable to single points of failure that can cause mation during failure-free execution, guarantees that, de- data corruption or loss. spite failures, the system will be left in a state consistent Salus provides strong end-to-end correctness guaran- with the ordering of writes specified by the client. tees for read operations, strict ordering guarantees for Active storage. To prevent a single computation node write operations, and strong durability and availability from corrupting data, Salus replicates both the storage and the computation layer. Salus applies an update to the 1Salus is the Roman goddess of safety and welfare system’s persistent state only if the update is agreed up- 1 USENIX Association 10th USENIX Symposium on Networked Systems Design and Implementation (NSDI ’13) 357 on by all of the replicated computation nodes. We make A volume’s interface supports GET and PUT, which on two observations about active storage. First, perhaps sur- a disk correspond to read and write. A client may have prisingly, replicating the computation nodes can actual- many such commands outstanding to maximize through- ly improve system performance by moving the computa- put. At any given time, only one client may mount a tion near the data (rather than vice versa), a good choice volume for writing, and during that time no other client when network bandwidth is a more limited resource than can mount the volume for reading. Different clients may CPU cycles. Second, by requiring the unanimous con- mount and write different volumes at the same time, and sent of all replicas before an update is applied, Salus multiple clients may simultaneously mount a read-only comes near to its perfect world with respect to over- snapshot of a volume. head: Salus remains safe (i.e. keeps its blocks consistent We explicitly designed Salus to support only a single and durable) despite two commission failures with just writer per volume for two reasons. First, as demonstrated three-way replication—the same degree of data replica- by the success of Amazon EBS, this model is sufficient tion needed by HBase to tolerate two permanent omis- to support disk-like storage. Second, we are not aware of sion failures. The flip side, of course, is that insisting on a design that would allow Salus to support multiple writ- unanimous consent can reduce the times during which ers while achieving its other goals: strong consistency,2 Salus is live (i.e. its blocks are available)—but liveness scalability, and end-to-end verification for read requests. is easily restored by replacing the faulty set of computa- Even though each volume has only a single writer at tion nodes with a new set that can use the storage layer to a time, a distributed block store has several advantages recover the state required to resume processing requests. over a local one. Spreading a volume across multiple Scalable end-to-end verification. Salus maintains a machines not only allows disk throughput and storage Merkle tree [32] for each volume so that a client can val- capacity to exceed the capabilities of a single machine, idate that each GET request returns consistent and correct but balances load and increases resource utilization. data: if not, the client can reissue the request to another To minimize cost, a typical server in existing storage replica. Reads can then safely proceed at a single replica deployments is relatively storage heavy, with a total ca- without leaving clients vulnerable to reading corrupted pacity of up to 24 TB [5, 42]. We expect a storage server data; more generally, such end-to-end assurances protec- in a Salus deployment to have ten or more SATA disks t Salus clients from the opportunities for error and cor- and two 1 Gbit/s network connections. In this configura- ruption that can arise in complex, black-box cloud stor- tion disk bandwidth is several times more plentiful than age solutions. Further, Salus’ Merkle tree, unlike those network bandwidth, so the Salus design seeks to mini- used in other systems that support end-to-end verifica- mize network bandwidth consumption. tion [19, 26, 31, 41], is scalable: each server only needs 2.1 Failure model to keep the sub-tree corresponding to its own data, and the client can rebuild and check the integrity of the w- Salus is designed to operate on an unreliable network hole tree even after failing and restarting from an empty with unreliable nodes. The network can drop, reorder, state. modify, or arbitrarily delay messages. We have prototyped Salus by modifying the HBase For storage nodes, we assume that 1) servers can key-value store. The evaluation confirms that Salus can crash and recover, temporarily making their disks’ data tolerate servers experiencing commission failures like unavailable (transient omission failure); 2) servers and memory corruption, disk corruption, etc. Although one disks can fail, permanently losing all their data (perma- might fear the performance price to be paid for Salus’ nent omission failure); 3) disks and the software that con- robustness, Salus’ overheads are low in all of our exper- trols them can cause corruption, where some blocks are iments. In fact, despite its strong guarantees, Salus often lost or modified, possibly silently [35] and servers can outperforms HBase, especially when disk bandwidth is experience memory corruption, software bugs, etc, send- plentiful compared to network bandwidth.
Recommended publications
  • Angela: a Sparse, Distributed, and Highly Concurrent Merkle Tree
    Angela: A Sparse, Distributed, and Highly Concurrent Merkle Tree Janakirama Kalidhindi, Alex Kazorian, Aneesh Khera, Cibi Pari Abstract— Merkle trees allow for efficient and authen- with high query throughput. Any concurrency overhead ticated verification of data contents through hierarchical should not destroy the system’s performance when the cryptographic hashes. Because the contents of parent scale of the merkle tree is very large. nodes in the trees are the hashes of the children nodes, Outside of Key Transparency, this problem is gen- concurrency in merkle trees is a hard problem. The eralizable to other applications that have the need current standard for merkle tree updates is a naive locking of the entire tree as shown in Google’s merkle tree for efficient, authenticated data structures, such as the implementation, Trillian. We present Angela, a concur- Global Data Plane file system. rent and distributed sparse merkle tree implementation. As a result of these needs, we have developed a novel Angela is distributed using Ray onto Amazon EC2 algorithm for updating a batch of updates to a merkle clusters and uses Amazon Aurora to store and retrieve tree concurrently. Run locally on a MacBook Pro with state. Angela is motivated by Google Key Transparency a 2.2GHz Intel Core i7, 16GB of RAM, and an Intel and inspired by it’s underlying merkle tree, Trillian. Iris Pro1536 MB, we achieved a 2x speedup over the Like Trillian, Angela assumes that a large number of naive algorithm mentioned earlier. We expanded this its 2256 leaves are empty and publishes a new root after algorithm into a distributed merkle tree implementation, some amount of time.
    [Show full text]
  • Enabling Authentication of Sliding Window Queries on Streams
    Proof­Infused Streams: Enabling Authentication of Sliding Window Queries On Streams Feifei Li† Ke Yi‡ Marios Hadjieleftheriou‡ George Kollios† †Computer Science Department Boston University ‡AT&T Labs Inc. lifeifei, gkollios @cs.bu.edu yike, marioh @research.att.com { } { } ABSTRACT As computer systems are essential components of many crit- ical commercial services, the need for secure online transac- . tions is now becoming evident. The demand for such appli- cations, as the market grows, exceeds the capacity of individ- 0110..011 ual businesses to provide fast and reliable services, making Provider Servers outsourcing technologies a key player in alleviating issues Clients of scale. Consider a stock broker that needs to provide a real-time stock trading monitoring service to clients. Since Figure 1: The outsourced stream model. the cost of multicasting this information to a large audi- ence might become prohibitive, the broker could outsource providers, who would be in turn responsible for forwarding the stock feed to third-party providers, who are in turn re- the appropriate sub-feed to clients (see Figure 1). Evidently, sponsible for forwarding the appropriate sub-feed to clients. especially in critical applications, the integrity of the third- Evidently, in critical applications the integrity of the third- party should not be taken for granted, as the latter might party should not be taken for granted. In this work we study have malicious intent or might be temporarily compromised a variety of authentication algorithms for selection and ag- by other malicious entities. Deceiving clients can be at- gregation queries over sliding windows. Our algorithms en- tempted for gaining business advantage over the original able the end-users to prove that the results provided by the service provider, for competition purposes against impor- third-party are correct, i.e., equal to the results that would tant clients, or for easing the workload on the third-party have been computed by the original provider.
    [Show full text]
  • Providing Authentication and Integrity in Outsourced Databases Using Merkle Hash Tree’S
    Providing Authentication and Integrity in Outsourced Databases using Merkle Hash Tree's Einar Mykletun Maithili Narasimha University of California Irvine University of California Irvine [email protected] [email protected] Gene Tsudik University of California Irvine [email protected] 1 Introduction In this paper we intend to describe and summarize results relating to the use of authenticated data structures, specifically Merkle Hash Tree's, in the context of the Outsourced Database Model (ODB). In ODB, organizations outsource their data management needs to an external untrusted service provider. The service provider hosts clients' databases and offers seamless mechanisms to create, store, update and access (query) their databases. Due to the service provider being untrusted, it becomes imperative to provide means to ensure authenticity and integrity in the query replies returned by the provider to clients. It is therefore the goal of this paper to outline an applicable data structure that can support authenticated query replies from the service provider to the clients (who issue the queries). Merkle Hash Tree's (introduced in section 3) is such a data structure. 1.1 Outsourced Database Model (ODB) The outsourced database model (ODB) is an example of the well-known Client-Server model. In ODB, the Database Service Provider (also referred to as the Server) has the infrastructure required to host outsourced databases and provides efficient mechanisms for clients to create, store, update and query the database. The owner of the data is identified as the entity who has to access to add, remove, and modify tuples in the database. The owner and the client may or may not be the same entity.
    [Show full text]
  • The SCADS Toolkit Nick Lanham, Jesse Trutna
    The SCADS Toolkit Nick Lanham, Jesse Trutna (it’s catching…) SCADS Overview SCADS is a scalable, non-relational datastore for highly concurrent, interactive workloads. Scale Independence - as new users join No changes to application Cost per user doesn’t increase Request latency doesn’t change Key Innovations 1. Performance safe query language 2. Declarative performance/consistency tradeoffs 3. Automatic scale up and down using machine learning Toolkit Motivation Investigated other open-source distributed key-value stores Cassandra, Hypertable, CouchDB Monolithic, opaque point solutions Make many decisions about how to architect the system a -prori Want set of components to rapidly explore the space of systems’ design Extensible components communicate over established APIs Understand the implications and performance bottlenecks of different designs SCADS Components Component Responsibilities Storage Layer Persist and serve data for a specified key responsibility Copy and sync data between storage nodes Data Placement Layer Assign node key responsibilities Manage replication and partition factors Provide clients with key to node mapping Provides mechanism for machine learning policies Client Library Hides client interaction with distributed storage system Provides higher-level constructs like indexes and query language Storage Layer Key-value store that supports range queries built on BDB API Record get(NameSpace ns, RecordKey key) list<Record> get_set (NameSpace ns, RecordSet rs ) bool put(NameSpace ns, Record rec) i32 count_set(NameSpace ns, RecordSet rs) bool set_responsibility_policy(NameSpace ns,RecordSet policy) RecordSet get_responsibility_policy(NameSpace ns) bool sync_set(NameSpace ns, RecordSet rs, Host h, ConflictPolicy policy) bool copy_set(NameSpace ns, RecordSet rs, Host h) bool remove_set(NameSpace ns, RecordSet rs) Storage Layer Storage Layer Storage Layer: Synchronize Replicas may diverge during network partitions (in order to preserve availability).
    [Show full text]
  • Authentication of Moving Range Queries
    Authentication of Moving Range Queries Duncan Yung Eric Lo Man Lung Yiu ∗ Department of Computing Hong Kong Polytechnic University {cskwyung, ericlo, csmlyiu}@comp.polyu.edu.hk ABSTRACT the user leaves the safe region, Thus, safe region is a powerful op- A moving range query continuously reports the query result (e.g., timization for significantly reducing the communication frequency restaurants) that are within radius r from a moving query point between the user and the service provider. (e.g., moving tourist). To minimize the communication cost with The query results and safe regions returned by LBS, however, the mobile clients, a service provider that evaluates moving range may not always be accurate. For instance, a hacker may infiltrate queries also returns a safe region that bounds the validity of query the LBS’s servers [25] so that results of queries all include a partic- results. However, an untrustworthy service provider may report in- ular location (e.g., the White House). Furthermore, the LBS may be correct safe regions to mobile clients. In this paper, we present effi- self-compromised and thus ranks sponsored facilities higher than cient techniques for authenticating the safe regions of moving range actual query result. The LBS may also return an overly large safe queries. We theoretically proved that our methods for authenticat- region to the clients for the sake of saving computing resources and ing moving range queries can minimize the data sent between the communication bandwidth [22, 16, 30]. On the other hand, the LBS service provider and the mobile clients. Extensive experiments are may opt to return overly small safe regions so that the clients have carried out using both real and synthetic datasets and results show to request new safe regions more frequently, if the LBS charges fee that our methods incur small communication costs and overhead.
    [Show full text]
  • Executing Large Scale Processes in a Blockchain
    The current issue and full text archive of this journal is available on Emerald Insight at: www.emeraldinsight.com/2514-4774.htm JCMS 2,2 Executing large-scale processes in a blockchain Mahalingam Ramkumar Department of Computer Science and Engineering, Mississippi State University, 106 Starkville, Mississippi, USA Received 16 May 2018 Revised 16 May 2018 Abstract Accepted 1 September 2018 Purpose – The purpose of this paper is to examine the blockchain as a trusted computing platform. Understanding the strengths and limitations of this platform is essential to execute large-scale real-world applications in blockchains. Design/methodology/approach – This paper proposes several modifications to conventional blockchain networks to improve the scale and scope of applications. Findings – Simple modifications to cryptographic protocols for constructing blockchain ledgers, and digital signatures for authentication of transactions, are sufficient to realize a scalable blockchain platform. Originality/value – The original contributions of this paper are concrete steps to overcome limitations of current blockchain networks. Keywords Cryptography, Blockchain, Scalability, Transactions, Blockchain networks Paper type Research paper 1. Introduction A blockchain broadcast network (Bozic et al., 2016; Croman et al., 2016; Nakamoto, 2008; Wood, 2014) is a mechanism for creating a distributed, tamper-proof, append-only ledger. Every participant in the broadcast network maintains a copy, or some representation, of the ledger. Ledger entries are made by consensus on the states of a process “executed” on the blockchain. As an example, in the Bitcoin (Nakamoto, 2008) process: (1) Bitcoin transactions transfer Bitcoins from a wallet to one or more other wallets. (2) Bitcoins created by “mining” are added to the miner’s wallet.
    [Show full text]
  • IB Case Study Vocabulary a Local Economy Driven by Blockchain (2020) Websites
    IB Case Study Vocabulary A local economy driven by blockchain (2020) Websites Merkle Tree: https://blockonomi.com/merkle-tree/ Blockchain: https://unwttng.com/what-is-a-blockchain Mining: https://www.buybitcoinworldwide.com/mining/ Attacks on Cryptocurrencies: https://blockgeeks.com/guides/hypothetical-attacks-on-cryptocurrencies/ Bitcoin Transaction Life Cycle: https://ducmanhphan.github.io/2018-12-18-Transaction-pool-in- blockchain/#transaction-pool 51 % attack - a potential attack on a blockchain network, where a single entity or organization can control the majority of the hash rate, potentially causing a network disruption. In such a scenario, the attacker would have enough mining power to intentionally exclude or modify the ordering of transactions. Block - records, which together form a blockchain. ... Blocks hold all the records of valid cryptocurrency transactions. They are hashed and encoded into a hash tree or Merkle tree. In the world of cryptocurrencies, blocks are like ledger pages while the whole record-keeping book is the blockchain. A block is a file that stores unalterable data related to the network. Blockchain - a data structure that holds transactional records and while ensuring security, transparency, and decentralization. You can also think of it as a chain or records stored in the forms of blocks which are controlled by no single authority. Block header – main way of identifying a block in a blockchain is via its block header hash. The block hash is responsible for block identification within a blockchain. In short, each block on the blockchain is identified by its block header hash. Each block is uniquely identified by a hash number that is obtained by double hashing the block header with the SHA256 algorithm.
    [Show full text]
  • Efficient Verification of Shortest Path Search Via Authenticated Hints Man Lung YIU Hong Kong Polytechnic University
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Institutional Knowledge at Singapore Management University Singapore Management University Institutional Knowledge at Singapore Management University Research Collection School Of Information Systems School of Information Systems 3-2010 Efficient Verification of Shortest Path Search Via Authenticated Hints Man Lung YIU Hong Kong Polytechnic University Yimin LIN Singapore Management University, [email protected] Kyriakos MOURATIDIS Singapore Management University, [email protected] DOI: https://doi.org/10.1109/ICDE.2010.5447914 Follow this and additional works at: https://ink.library.smu.edu.sg/sis_research Part of the Databases and Information Systems Commons, and the Numerical Analysis and Scientific omputC ing Commons Citation YIU, Man Lung; LIN, Yimin; and MOURATIDIS, Kyriakos. Efficient Verification of Shortest Path Search Via Authenticated Hints. (2010). ICDE 2010: IEEE 26th International Conference on Data Engineering: Long Beach, California, USA, 1 - 6 March 2010. 237-248. Research Collection School Of Information Systems. Available at: https://ink.library.smu.edu.sg/sis_research/507 This Conference Proceeding Article is brought to you for free and open access by the School of Information Systems at Institutional Knowledge at Singapore Management University. It has been accepted for inclusion in Research Collection School Of Information Systems by an authorized administrator of Institutional Knowledge at Singapore Management University.
    [Show full text]
  • Redactable Hashing for Time Verification
    Technical Disclosure Commons Defensive Publications Series January 2021 Redactable Hashing for Time Verification Jan Schejbal Follow this and additional works at: https://www.tdcommons.org/dpubs_series Recommended Citation Schejbal, Jan, "Redactable Hashing for Time Verification", Technical Disclosure Commons, (January 24, 2021) https://www.tdcommons.org/dpubs_series/3999 This work is licensed under a Creative Commons Attribution 4.0 License. This Article is brought to you for free and open access by Technical Disclosure Commons. It has been accepted for inclusion in Defensive Publications Series by an authorized administrator of Technical Disclosure Commons. Schejbal: Redactable Hashing for Time Verification REDACTABLE HASHING FOR TIME VERIFICATION Cryptographic hashes (outputs of cryptographically secure hash functions) are used to uniquely identify secret information without making such information public. A cryptographic hash function is a deterministic computation that produces the same outputs for the same inputs while ensuring that even a small change of the input (e.g., a change of only one or several bits) results in an unpredictable output that has little resemblance to the original (unmodified) input. Furthermore, it is not possible to efficiently find an input matching a certain hash value or two different inputs having the same hash value; an attacker that attempts to do so would need to test numerous values until one matches, which is computationally infeasible for a sufficiently large space of possible values. The quasi-randomness property of hashes makes them useful for mapping protected information while ensuring that the information is not easily discoverable by a malicious attacker or an unauthorized viewer. Hashes can be used to derive cryptographic keys from other (strong or even weak) cryptographic material.
    [Show full text]
  • "On Merkle Trees", Dr Craig S Wright
    On Merkle Trees Dr Craig S Wright By now, it should be well understood that Bitcoin utilises the concept of a Merkle tree to its advantage; by way of background, we provide an explanation in this post. The following aids as a technical description and definition of similar concepts used more generally in Bitcoin and specifically within SPV. Merkle trees are hierarchical data structures that enable secure verification of collections of data. In a Merkle tree, each node in the tree has been given an index pair (i, j) and is represented as N(i, j). The indices i, j are simply numerical labels that are related to a specific position in the tree. An important feature of the Merkle tree is that the construction of each of its nodes is governed by the following (simplified) equations: 퐻(퐷 ) 푖 = 푗 푁(푖, 푗) = { 푖 , 퐻(푁(푖, 푘) ∥ 푁(푘 + 1, 푗)) 푖 ≠ 푗 where 푘 = (푖 + 푗 − 1)⁄2 and H is a cryptographic hash function. A labelled, binary Merkle tree constructed according to the equations is shown in figure 1, from which we can see that the i = j case corresponds to a leaf node, which is simply the hash of the th corresponding i packet of data Di. The 푖 ≠ 푗 case corresponds to an internal or parent node, which is generated by recursively hashing and concatenating child nodes, until one parent (the Merkle root) is found. Figure 1. A Merkle tree. For example, the node 푁(1,4) is constructed from the four data packets 퐷1, … , 퐷4 as 푁(1,4) = 퐻(푁(1,2) ∥ 푁(3,4)) .
    [Show full text]
  • Practical Authenticated Pattern Matching with Optimal Proof Size
    Practical Authenticated Pattern Matching with Optimal Proof Size Dimitrios Papadopoulos Charalampos Papamanthou Boston University University of Maryland [email protected] [email protected] Roberto Tamassia Nikos Triandopoulos Brown University RSA Laboratories & Boston University [email protected] [email protected] ABSTRACT otherwise. More elaborate models for pattern matching involve We address the problem of authenticating pattern matching queries queries expressed as regular expressions over Σ or returning multi- over textual data that is outsourced to an untrusted cloud server. By ple occurrences of p, and databases allowing search over multiple employing cryptographic accumulators in a novel optimal integrity- texts or other (semi-)structured data (e.g., XML data). This core checking tool built directly over a suffix tree, we design the first data-processing problem has numerous applications in a wide range authenticated data structure for verifiable answers to pattern match- of topics including intrusion detection, spam filtering, web search ing queries featuring fast generation of constant-size proofs. We engines, molecular biology and natural language processing. present two main applications of our new construction to authen- Previous works on authenticated pattern matching include the ticate: (i) pattern matching queries over text documents, and (ii) schemes by Martel et al. [28] for text pattern matching, and by De- exact path queries over XML documents. Answers to queries are vanbu et al. [16] and Bertino et al. [10] for XML search. In essence, verified by proofs of size at most 500 bytes for text pattern match- these works adopt the same general framework: First, by hierarchi- ing, and at most 243 bytes for exact path XML search, indepen- cally applying a cryptographic hash function (e.g., SHA-2) over the dently of the document or answer size.
    [Show full text]
  • A New Blockchain-Based Multi-Level Location Secure Sharing Scheme
    applied sciences Article A New Blockchain-Based Multi-Level Location Secure Sharing Scheme Qiuhua Wang 1,* , Tianyu Xia 1, Yizhi Ren 1, Lifeng Yuan 1 and Gongxun Miao 2 1 School of Cyberspace, Hangzhou Dianzi University, Hangzhou 310018, China; [email protected] (T.X.); [email protected] (Y.R.); [email protected] (L.Y.) 2 Zhongfu Information Co., Ltd., Jinan 250101, China; [email protected] * Correspondence: [email protected]; Tel.: +86-0571-868-73820 Abstract: Currently, users’ location information is collected to provide better services or research. Using a central server to collect, store and share location information has inevitable defects in terms of security and efficiency. Using the point-to-point sharing method will result in high computation overhead and communication overhead for users, and the data are hard to be verified. To resolve these issues, we propose a new blockchain-based multi-level location secure sharing scheme. In our proposed scheme, the location data are set hierarchically and shared with the requester according to the user’s policy, while the received data can be verified. For this, we design a smart contract to implement attribute-based access control and establish an incentive and punishment mechanism. We evaluate the computation overhead and the experimental results show that the computation overhead of our proposed scheme is much lower than that of the existing scheme. Finally, we analyze the performances of our proposed scheme and demonstrate that our proposed scheme is, overall, better than existing schemes. Keywords: location sharing; privacy preserving; blockchain; Merkle tree; smart contract; attribute- Citation: Wang, Q.; Xia, T.; Ren, Y.; based access control Yuan, L.; Miao, G.
    [Show full text]