Traditional resilient systems operate on fully-replicated fault-tolerant clusters, which limits their scalability and performance. One way to make the step towards resilient high-performance systems that can deal with huge workloads, is by enabling independent fault-tolerant clusters to efficiently communicate and cooperate with each other, as this also enables the usage of high-performance techniques such as sharding. Recently, such inter-cluster communication was formalized as the Byzantine cluster-sending problem. Unfortunately, existing worst-case optimal protocols for cluster-sending all have linear complexity in the size of the clusters involved. 

In this paper, we propose probabilistic cluster-sending techniques as a solution for the cluster-sending problem with only an expected constant message complexity, this independent of the size of the clusters involved and this even in the presence of highly unreliable communication. Depending on the robustness of the clusters involved, our techniques require only two-to-four message round-trips (without communication failures). Furthermore, our protocols can support worst-case linear communication between clusters. Finally, we have put our techniques to the test in an in-depth experimental evaluation that further underlines the exceptional low expected costs of our techniques in comparison with other protocols. As such, our work provides a strong foundation for the further development of resilient high-performance systems.

Solution: Byzantine Cluster-Sending in Expected Constant Cost and Constant Time

To enable scalable resilient blockchain systems, several powerful general-purpose approaches toward sharding such systems have been demonstrated. Unfortunately, these approaches all come with substantial costs for ordering and execution of multi-shard transactions.

In this work, we ask whether one can achieve significant cost reductions for processing multi-shard transactions by limiting the type of workloads supported. To initiate the study of this problem, we propose core-Chimera (CChimera). CChimera uses strict UTXO-based environmental requirements to enable powerful multi-shard transaction processing with an absolute minimum amount of coordination between shards. In the environment we designed CChimera for, CChimera will operate perfectly with respect to all transactions proposed and approved by well-behaved clients, but does not provide any other guarantees. 

To illustrate that CChimera-like protocols can be of use in non-UTXO environments, we also demonstrate two generalizations of CChimera, optimistic-Chimera and resilient-Chimera, that make different tradeoffs in complexity and costs when dealing with faulty behavior and attacks. Finally, we compare these three protocols and show their potential scalability and performance benefits over state-of-the-art general-purpose systems. These results underline the importance of the study of specialized approaches toward sharding in resilient systems.  

Problem: Sharded Resilient Transaction Processing with Minimal Costs

To evaluate the severity of a security vulnerability a security
researcher usually tries to prove its exploitability by writing
an actual exploit. In the case of buffer overflows on the heap,
a necessary part of this is manipulating the heap layout in
a way that creates an exploitable state, usually by placing a
vulnerable object adjacent to a target object. This requires
manual effort and extensive knowledge of the target. With a
target as complex as the Linux kernel, this problem becomes
highly non-trivial. At the current time, there has been only
little research in terms of employing algorithmic solutions for
this. In this work, we present Kernel-SIEVE, a framework for
evaluating heap layout manipulation algorithms that target the
SLAB/SLUB allocator in the Linux kernel. Inspired by previous
work that targets user-space allocators it provides
an interface for triggering allocations/deallocations in the kernel
and contains a feedback loop that returns the resulting
distance of two target objects. With this, we create the (to
our knowledge) first performance benchmarks for heap layout
manipulation algorithms in the Linux kernel. We present and
evaluate two algorithms: A pseudo-random search, which’s
performance serves as a baseline, and KEvoHeap, a genetic
algorithm based on Heelan’s EvoHeap. We show that
KEvoHeap is successful at creating the desired heap layout in
all test cases and also surpasses the user-space performance
benchmarks of EvoHeap. Finally, we discuss the challenges
of applying these kinds of algorithms in real-world scenarios
and weigh different possible approaches to tackle the problems
that arise.

JSYS 2022 May Papers Submissions

Solution: Byzantine Cluster-Sending in Expected Constant Cost and Constant Time

Problem: Sharded Resilient Transaction Processing with Minimal Costs

Algorithmic Heap Layout Manipulation in the Linux Kernel