Confidentiality, integrity protection, and high availability, abbreviated to CIA, are essential properties for trustworthy data systems. The rise of cloud computing and the growing demand for multiparty applications however means that building modern CIA systems is more challenging than ever. In response, we present the Confidential Consortium Framework (CCF), a general-purpose foundation for developing secure stateful CIA applications. CCF combines centralized compute with decentralized trust, supporting deployment on untrusted cloud infrastructure and transparent governance by mutually untrusted parties. CCF leverages hardware-based trusted execution environments for remotely verifiable confidentiality and code integrity. This is coupled with state machine replication backed by an auditable immutable ledger for data integrity and high availability. CCF enables each service to bring its own application logic, custom multiparty governance model, and deployment scenario, decoupling the operators of nodes from the consortium that governs them. CCF is open-source and available now at https://github.com/microsoft/CCF.

Single-node multi-core stream processing engines (SPEs) can process hundreds of millions of tuples per second. Yet making them fault-tolerant with exactly-once semantics while retaining this performance is an open challenge: due to the limited I/O bandwidth of a single-node, it becomes infeasible to persist all stream data and operator state during execution. Instead, single-node SPEs rely on upstream distributed systems, such as Apache Kafka, to recover stream data after failure, necessitating complex cluster-based deployments. This lack of built-in fault-tolerance features has hindered the adoption of single-node SPEs. We describe Scabbard, the first single-node SPE that supports exactly-once fault-tolerance semantics despite limited local I/O bandwidth. Scabbard achieves this by integrating persistence operations with the query workload. Within the operator graph, Scabbard determines when to persist streams based on the selectivity of operators: by persisting streams after operators that discard data, it can substantially reduce the required I/O bandwidth. As part of the operator graph, Scabbard supports parallel persistence operations and uses markers to decide when to discard persisted data. The persisted data volume is further reduced using workload-specific compression: Scabbard monitors stream statistics and dynamically generates computationally efficient compression operators. Our experiments show that Scabbard can execute stream queries that process over 200 million tuples per second while recovering from failures with sub-second latencies.

Integrated circuits can be modified with malicious circuitries, like hardware trojans. The use of these circuitries, is either to leak confidential information, or disable security fence of a system, or even to the total destroy of the chip. In this work, several shift registers and a set of logic gates were used to implement key generators. A malicious hardware trojan circuit was added in the combinational circuit, to leak information that were generated. Only a few logical gates are needed to effectively trigger the malicious circuitry, in combination with a flip-flop. These additional gates, have to be included between the shift registers, to be triggered by certain signals, and not to leak in every clock cycle. Taking the advantage of the trigger effect, the malicious circuitry is not delaying the key generators. By implementing the above system, the ability of a hardware trojan to be stealthy under many circumstances, is proven. It is also introduced, from the low demand of logic gates, the little space that is obtained as the effect. It is also proven by the implementation, the very low cost of additional time, which is really needed to perform the leak. Merging those two advantages, the modified circuit that is resulted, is hard to be detected, by a number of applied methods. In particular, in this work a hardware trojan is implemented and added in a stream cipher hardware integration. It is proven, by the implementation results, that the spatial burden is about 2% while the temporal burden is about 3%.