The Experts below are selected from a list of 1707 Experts worldwide ranked by ideXlab platform

Thomas Schwarz - One of the best experts on this subject based on the ideXlab platform.

  • Online Appendix to: LH ∗ —A Highly-Available Scalable Distributed Data Structure
    2020
    Co-Authors: Witold Litwin, Rim Moussa, Universit, Thomas Schwarz
    Abstract:

    The Image Adjustment Algorithm that LHRS client executes to update its image when the IAM comes back is as follows. Here a is the address of the last bucket to forward the request to the correct one, and j is the level of bucket a. These values are in IAM. Notice that they come from a different bucket than that considered in Litwin et al. [1996]. The latter was the first bucket to receive the request. The change produces the image whose extent is closer to the actual one in many cases. The search for key c = 60 in the file in Figure 1(b) illustrates one such case.

  • Disk Backup Through Algebraic Signatures in Scalable Distributed Data Structures
    2020
    Co-Authors: Witold Litwin, Riad Mokadem, Thomas Schwarz
    Abstract:

    A Scalable Distributed Data Structure (SDDS) allows to store a large scalable file over a Distributed RAM. The file scales up transparently for the application over the nodes of a multicomputer, e.g., a local network of PCs. The prototype system termed SDDS 2000, designed by CERIA experiments with this technology for Wintel multicomputers. The application may manipulate Data much faster than on local disks. We present the functions we have added to SDDS-2000 to backup the RAM on each storage node onto the local disk. Our goal is to write only the Data that has changed since the last backup. We experiment for this purpose with the algebraic signatures. We present our architecture and design choices. Performance measures validate our implementation. It is now available for the noncommercial use as part of new version of our prototype termed SDDS-2002. 1. Introduction A Scalable Distributed Data Structure (SDDS) allows to store a large scalable file over a Distributed RAM. The file scales up transparently for the application over the storage nodes of a multicomputer, e.g., a local network of PCs and WSs. The storage nodes are called the (SDDS) server nodes. The application manipulates through the SDDS interface at its node, called the (SDDS) client node. The client node performs the (scalable) address calculus and handles the application requests accordingly. Various SDDS schemes have been investigated, [C]. Probably the most studied were the linear hash partitioning variants of the LH* scheme, and the range

  • LH*RE: A Scalable Distributed Data Structure with Recoverable Encryption
    2010 IEEE 3rd International Conference on Cloud Computing, 2010
    Co-Authors: Sushil Jajodia, Witold Litwin, Thomas Schwarz
    Abstract:

    LH*RE is a new Scalable Distributed Data Structure (SDDS) for hash files stored in a cloud. The client-side symmetric encryption protects the Data against the server-side disclosure. The encryption key(s) at the client are backed up in the file. The client may recover/revoke any keys lost or stolen from its node. A trusted official can also do it on behalf of the client or of an authority, e.g., to imperatively access the Data of a client missing or disabled. In contrast, with high assurance, e.g., 99%, the attacker of the cloud should not usually disclose any Data, even if the intrusion succeeds over dozens or possibly thousands of servers for a larger file. Storage and primary key-based access performance of LH*RE should be about those of the well-known LH* SDDS. Two messages should typically suffice for a key-based search and four in the worst case, with the application Data load factor of 70%, regardless of the file scale up. These features are among most efficient for a hash SDDS. LH*RE should be attractive with respect to the competition.

  • IEEE CLOUD - LH*RE: A Scalable Distributed Data Structure with Recoverable Encryption
    2010 IEEE 3rd International Conference on Cloud Computing, 2010
    Co-Authors: Sushil Jajodia, Witold Litwin, Thomas Schwarz
    Abstract:

    LH*RE is a new Scalable Distributed Data Structure (SDDS) for hash files stored in a cloud. The client-side symmetric encryption protects the Data against the server-side disclosure. The encryption key(s) at the client are backed up in the file. The client may recover/ revoke any keys lost or stolen from its node. A trusted official can also do it on behalf of the client or of an authority, e.g., to imperatively access the Data of a client missing or disabled. In contrast, with high assurance, e.g., 99%, the attacker of the cloud should not usually disclose any Data, even if the intrusion succeeds over dozens or possibly thousands of servers for a larger file. Storage and primary key-based access performance of LH*RE should be about those of the well-known LH* SDDS. Two messages should typically suffice for a key-based search and four in the worst case, with the application Data load factor of 70%, regardless of the file scale up. These features are among most efficient for a hash SDDS. LH*RE should be attractive with respect to the competition.

  • lh rs p2p a scalable Distributed Data Structure for p2p environment
    Proceedings of the 8th international conference on New technologies in distributed systems, 2008
    Co-Authors: Witold Litwin, Hanafi Yakouben, Thomas Schwarz
    Abstract:

    LH*RSP2P is a Scalable Distributed Data Structure (SDDS) designed for P2P applications. It stores and processes Data on SDDS peer nodes. Each node is both an SDDS client and, actually or potentially, an SDDS server with application or parity Data. The scheme improves on LH*RS. The basic difference is that now key-based queries require at most one forwarding message, instead of possibly two for LH*RS. This property makes LH*RSP2P the fastest P2P or SDDS addressing scheme. The scan operation now also takes at most two rounds. LH*RSP2P parity management reuses the LH*RS Reed Salomon erasure correction scheme to deal efficiently with churn. The file supports unavailability or withdrawal of up to any k ≥ 1 peers, where k is a parameter that can scale dynamically. We discuss the LH*RSP2P design, implementation issues and variants, as well as related work.

Witold Litwin - One of the best experts on this subject based on the ideXlab platform.

  • Disk Backup Through Algebraic Signatures in Scalable Distributed Data Structures
    2020
    Co-Authors: Witold Litwin, Riad Mokadem, Thomas Schwarz
    Abstract:

    A Scalable Distributed Data Structure (SDDS) allows to store a large scalable file over a Distributed RAM. The file scales up transparently for the application over the nodes of a multicomputer, e.g., a local network of PCs. The prototype system termed SDDS 2000, designed by CERIA experiments with this technology for Wintel multicomputers. The application may manipulate Data much faster than on local disks. We present the functions we have added to SDDS-2000 to backup the RAM on each storage node onto the local disk. Our goal is to write only the Data that has changed since the last backup. We experiment for this purpose with the algebraic signatures. We present our architecture and design choices. Performance measures validate our implementation. It is now available for the noncommercial use as part of new version of our prototype termed SDDS-2002. 1. Introduction A Scalable Distributed Data Structure (SDDS) allows to store a large scalable file over a Distributed RAM. The file scales up transparently for the application over the storage nodes of a multicomputer, e.g., a local network of PCs and WSs. The storage nodes are called the (SDDS) server nodes. The application manipulates through the SDDS interface at its node, called the (SDDS) client node. The client node performs the (scalable) address calculus and handles the application requests accordingly. Various SDDS schemes have been investigated, [C]. Probably the most studied were the linear hash partitioning variants of the LH* scheme, and the range

  • Performance Measurements of RP* : A Scalable Distributed Data Structure For Range Partitioning
    2020
    Co-Authors: Aly Wane Diene, Witold Litwin
    Abstract:

    The RP* scheme generates the scalable range partitioning. The intervals at the Data servers adjust dynamically so that new servers accommodate the file growth transparently for the application. We have implemented variants of RP* on a Windows 2000 multicomputer. We have measured the performance of the system. The experiments prove high efficiency of our implementation. RP* should be of importance to future main-memory parallel DBMSs.

  • Online Appendix to: LH ∗ —A Highly-Available Scalable Distributed Data Structure
    2020
    Co-Authors: Witold Litwin, Rim Moussa, Universit, Thomas Schwarz
    Abstract:

    The Image Adjustment Algorithm that LHRS client executes to update its image when the IAM comes back is as follows. Here a is the address of the last bucket to forward the request to the correct one, and j is the level of bucket a. These values are in IAM. Notice that they come from a different bucket than that considered in Litwin et al. [1996]. The latter was the first bucket to receive the request. The change produces the image whose extent is closer to the actual one in many cases. The search for key c = 60 in the file in Figure 1(b) illustrates one such case.

  • LH*RE: A Scalable Distributed Data Structure with Recoverable Encryption
    2010 IEEE 3rd International Conference on Cloud Computing, 2010
    Co-Authors: Sushil Jajodia, Witold Litwin, Thomas Schwarz
    Abstract:

    LH*RE is a new Scalable Distributed Data Structure (SDDS) for hash files stored in a cloud. The client-side symmetric encryption protects the Data against the server-side disclosure. The encryption key(s) at the client are backed up in the file. The client may recover/revoke any keys lost or stolen from its node. A trusted official can also do it on behalf of the client or of an authority, e.g., to imperatively access the Data of a client missing or disabled. In contrast, with high assurance, e.g., 99%, the attacker of the cloud should not usually disclose any Data, even if the intrusion succeeds over dozens or possibly thousands of servers for a larger file. Storage and primary key-based access performance of LH*RE should be about those of the well-known LH* SDDS. Two messages should typically suffice for a key-based search and four in the worst case, with the application Data load factor of 70%, regardless of the file scale up. These features are among most efficient for a hash SDDS. LH*RE should be attractive with respect to the competition.

  • IEEE CLOUD - LH*RE: A Scalable Distributed Data Structure with Recoverable Encryption
    2010 IEEE 3rd International Conference on Cloud Computing, 2010
    Co-Authors: Sushil Jajodia, Witold Litwin, Thomas Schwarz
    Abstract:

    LH*RE is a new Scalable Distributed Data Structure (SDDS) for hash files stored in a cloud. The client-side symmetric encryption protects the Data against the server-side disclosure. The encryption key(s) at the client are backed up in the file. The client may recover/ revoke any keys lost or stolen from its node. A trusted official can also do it on behalf of the client or of an authority, e.g., to imperatively access the Data of a client missing or disabled. In contrast, with high assurance, e.g., 99%, the attacker of the cloud should not usually disclose any Data, even if the intrusion succeeds over dozens or possibly thousands of servers for a larger file. Storage and primary key-based access performance of LH*RE should be about those of the well-known LH* SDDS. Two messages should typically suffice for a key-based search and four in the worst case, with the application Data load factor of 70%, regardless of the file scale up. These features are among most efficient for a hash SDDS. LH*RE should be attractive with respect to the competition.

Mohammad Ghodsi - One of the best experts on this subject based on the ideXlab platform.

  • skiptree a new scalable Distributed Data Structure on multidimensional Data supporting range queries
    Computer Communications, 2010
    Co-Authors: Saeed Alaei, Mohammad Ghodsi, Mohammad Toossi
    Abstract:

    This paper presents a new balanced, Distributed Data Structure for storing Data with multidimensional keys in a peer-to-peer network. It supports range queries as well as single point queries which are routed in O(logn) hops. Our Structure, called SkipTree, is fully decentralized with each node being connected to O(logn) other nodes. We propose modifications to the Structures, so that the memory usage for maintaining the link Structure at each node is reduced from the worst case of O(n) to O(lognloglogn) on the average and O(log^2n) in the worst case. It is also shown that the load balancing is guaranteed to be within a constant factor. Our experimental results verify our theoretical proofs.

  • skiptree a scalable range queryable Distributed Data Structure for multidimensional Data
    International Symposium on Algorithms and Computation, 2005
    Co-Authors: Saeed Alaei, Mohammad Toossi, Mohammad Ghodsi
    Abstract:

    This paper presents the SkipTree, a new balanced, Distributed Data Structure for storing Data with multidimensional keys in a peer-to-peer network. The SkipTree supports range queries as well as single point queries which are routed in O(log n) hops. SkipTree is fully decentralized with each node being connected to O(log n) other nodes. The memory usage for maintaining the links at each node is O(log n log log n) on average and O(log2n) in the worst case. Load balance is also guaranteed to be within a constant factor.

  • ISAAC - SkipTree: a scalable range-queryable Distributed Data Structure for multidimensional Data
    Algorithms and Computation, 2005
    Co-Authors: Saeed Alaei, Mohammad Toossi, Mohammad Ghodsi
    Abstract:

    This paper presents the SkipTree, a new balanced, Distributed Data Structure for storing Data with multidimensional keys in a peer-to-peer network. The SkipTree supports range queries as well as single point queries which are routed in O(log n) hops. SkipTree is fully decentralized with each node being connected to O(log n) other nodes. The memory usage for maintaining the links at each node is O(log n log log n) on average and O(log2n) in the worst case. Load balance is also guaranteed to be within a constant factor.

  • raq a range queriable Distributed Data Structure
    Conference on Current Trends in Theory and Practice of Informatics, 2005
    Co-Authors: Hamid Nazerzadeh, Mohammad Ghodsi
    Abstract:

    Different Structures are used in peer-to-peer networks to represent their inherently Distributed, self-organized, and decentralized memory Structure. In this paper, a simple range-queriable Distributed Data Structure, called RAQ, is proposed to efficiently support exact match and range queries over multi-dimensional Data. In RAQ, the key space is partitioned among the network with n nodes, in which each element has links to O(log n) other elements. We will show that the look-up query for a specified key can be done via O(log n) message passing. Also, RAQ handles range-queries in at most O(log n) communication steps.

  • SOFSEM - RAQ: a range-queriable Distributed Data Structure
    SOFSEM 2005: Theory and Practice of Computer Science, 2005
    Co-Authors: Hamid Nazerzadeh, Mohammad Ghodsi
    Abstract:

    Different Structures are used in peer-to-peer networks to represent their inherently Distributed, self-organized, and decentralized memory Structure. In this paper, a simple range-queriable Distributed Data Structure, called RAQ, is proposed to efficiently support exact match and range queries over multi-dimensional Data. In RAQ, the key space is partitioned among the network with n nodes, in which each element has links to O(log n) other elements. We will show that the look-up query for a specified key can be done via O(log n) message passing. Also, RAQ handles range-queries in at most O(log n) communication steps.

Michael J Nelson - One of the best experts on this subject based on the ideXlab platform.

  • the rainbow skip graph a fault tolerant constant degree Distributed Data Structure
    Symposium on Discrete Algorithms, 2006
    Co-Authors: Michael T Goodrich, Michael J Nelson
    Abstract:

    We present a Distributed Data Structure, which we call the rainbow skip graph. To our knowledge, this is the first peer-to-peer Data Structure that simultaneously achieves high fault-tolerance, constant-sized nodes, and fast update and query times for ordered Data. It is a non-trivial adaptation of the SkipNet/skip-graph Structures of Harvey et al. and Aspnes and Shah, so as to provide fault-tolerance as these Structures do, but to do so using constant-sized nodes, as in the family tree Structure of Zatloukal and Harvey. It supports successor queries on a set of n items using O(log n) messages with high probability, an improvement over the expected O(log n) messages of the family tree. Our Structure achieves these results by using the following new constructs:• Rainbow connections: parallel sets of pointers between related components of nodes, so as to achieve good connectivity between "adjacent" components, using constant-sized nodes.• Hydra components: highly-connected, highly fault-tolerant components of constant-sized nodes, which will contain relatively large connected subcomponents even under the failure of a constant fraction of the nodes in the component.We further augment the hydra components in the rainbow skip graph by using erasure-resilient codes to ensure that any large subcomponent of nodes in a hydra component is sufficient to reconstruct all the Data stored in that component. By carefully maintaining the size of related components and hydra components to be O(log n), we are able to achieve fast times for updates and queries in the rainbow skip graph. In addition, we show how to make the communication complexity for updates and queries be worst case, at the expense of more conceptual complexity and a slight degradation in the node congestion of the Data Structure.

  • SODA - The rainbow skip graph: a fault-tolerant constant-degree Distributed Data Structure
    Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm - SODA '06, 2006
    Co-Authors: Michael T Goodrich, Michael J Nelson
    Abstract:

    We present a Distributed Data Structure, which we call the rainbow skip graph. To our knowledge, this is the first peer-to-peer Data Structure that simultaneously achieves high fault-tolerance, constant-sized nodes, and fast update and query times for ordered Data. It is a non-trivial adaptation of the SkipNet/skip-graph Structures of Harvey et al. and Aspnes and Shah, so as to provide fault-tolerance as these Structures do, but to do so using constant-sized nodes, as in the family tree Structure of Zatloukal and Harvey. It supports successor queries on a set of n items using O(log n) messages with high probability, an improvement over the expected O(log n) messages of the family tree. Our Structure achieves these results by using the following new constructs:• Rainbow connections: parallel sets of pointers between related components of nodes, so as to achieve good connectivity between "adjacent" components, using constant-sized nodes.• Hydra components: highly-connected, highly fault-tolerant components of constant-sized nodes, which will contain relatively large connected subcomponents even under the failure of a constant fraction of the nodes in the component.We further augment the hydra components in the rainbow skip graph by using erasure-resilient codes to ensure that any large subcomponent of nodes in a hydra component is sufficient to reconstruct all the Data stored in that component. By carefully maintaining the size of related components and hydra components to be O(log n), we are able to achieve fast times for updates and queries in the rainbow skip graph. In addition, we show how to make the communication complexity for updates and queries be worst case, at the expense of more conceptual complexity and a slight degradation in the node congestion of the Data Structure.

Jorge Guajardo - One of the best experts on this subject based on the ideXlab platform.

  • practical and secure dynamic searchable encryption via oblivious access on Distributed Data Structure
    Annual Computer Security Applications Conference, 2016
    Co-Authors: Thang Hoang, Attila A Yavuz, Jorge Guajardo
    Abstract:

    Dynamic Searchable Symmetric Encryption (DSSE) allows a client to perform keyword searches over encrypted files via an encrypted Data Structure. Despite its merits, DSSE leaks search and update patterns when the client accesses the encrypted Data Structure. These leakages may create severe privacy problems as already shown, for example, in recent statistical attacks on DSSE. While Oblivious Random Access Memory (ORAM) can hide such access patterns, it incurs significant communication overhead and, therefore, it is not yet fully practical for cloud computing systems. Hence, there is a critical need to develop private access schemes over the encrypted Data Structure that can seal the leakages of DSSE while achieving practical search/update operations. In this paper, we propose a new oblivious access scheme over the encrypted Data Structure for searchable encryption purposes, that we call D istributed O blivious D ata Structure DSSE (DOD-DSSE). The main idea is to create a Distributed encrypted incidence matrix on two non-colluding servers such that no arbitrary queries on these servers can be linked to each other. This strategy prevents not only recent statistical attacks on the encrypted Data Structure but also other potential threats exploiting query linkability. Our security analysis proves that DOD-DSSE ensures the unlink-ability of queries and, therefore, offers much higher security than traditional DSSE. At the same time, our performance evaluation demonstrates that DOD-DSSE is two orders of magnitude faster than ORAM-based techniques (e.g., Path ORAM), since it only incurs a small-constant number of communication overhead. That is, we deployed DOD-DSSE on geographically Distributed Amazon EC2 servers, and showed that, a search/update operation on a very large Dataset only takes around one second with DOD-DSSE, while it takes 3 to 13 minutes with Path ORAM-based methods.

  • ACSAC - Practical and secure dynamic searchable encryption via oblivious access on Distributed Data Structure
    Proceedings of the 32nd Annual Conference on Computer Security Applications, 2016
    Co-Authors: Thang Hoang, Attila A Yavuz, Jorge Guajardo
    Abstract:

    Dynamic Searchable Symmetric Encryption (DSSE) allows a client to perform keyword searches over encrypted files via an encrypted Data Structure. Despite its merits, DSSE leaks search and update patterns when the client accesses the encrypted Data Structure. These leakages may create severe privacy problems as already shown, for example, in recent statistical attacks on DSSE. While Oblivious Random Access Memory (ORAM) can hide such access patterns, it incurs significant communication overhead and, therefore, it is not yet fully practical for cloud computing systems. Hence, there is a critical need to develop private access schemes over the encrypted Data Structure that can seal the leakages of DSSE while achieving practical search/update operations. In this paper, we propose a new oblivious access scheme over the encrypted Data Structure for searchable encryption purposes, that we call D istributed O blivious D ata Structure DSSE (DOD-DSSE). The main idea is to create a Distributed encrypted incidence matrix on two non-colluding servers such that no arbitrary queries on these servers can be linked to each other. This strategy prevents not only recent statistical attacks on the encrypted Data Structure but also other potential threats exploiting query linkability. Our security analysis proves that DOD-DSSE ensures the unlink-ability of queries and, therefore, offers much higher security than traditional DSSE. At the same time, our performance evaluation demonstrates that DOD-DSSE is two orders of magnitude faster than ORAM-based techniques (e.g., Path ORAM), since it only incurs a small-constant number of communication overhead. That is, we deployed DOD-DSSE on geographically Distributed Amazon EC2 servers, and showed that, a search/update operation on a very large Dataset only takes around one second with DOD-DSSE, while it takes 3 to 13 minutes with Path ORAM-based methods.