Winning Against any Adversary on Commodity Computer Systems

Commodity computer systems contain more and more processor cores and exhibit increasingly diverse architectural tradeoffs, including memory hierarchies, interconnects, instruction sets and variants, and IO configurations. Previous high-performance computing systems have scaled in specific cases, but the dynamic nature of modern client and server workloads, coupled with the impossibility of statically optimizing an OS for all workloads and hardware variants pose serious challenges for operating system structures.We argue that the challenge of future multicore hardware is best met by embracing the networked nature of the machine, rethinking OS architecture using ideas from distributed systems. We investigate a new OS structure, the multikernel, that treats the machine as a network of independent cores, assumes no inter-core sharing at the lowest level, and moves traditional OS functionality to a distributed system of processes that communicate via message-passing.We have implemented a multikernel OS to show that the approach is promising, and we describe how traditional scalability problems for operating systems (such as memory management) can be effectively recast using messages and can exploit insights from distributed systems and networking. An evaluation of our prototype on multicore systems shows that, even on present-day machines, the performance of a multikernel is comparable with a conventional OS, and can scale better to support future hardware.

Trusted computing provides an efficient and practical way out for system security problems based on a trusted hardware, namely the root of trust, e.g., Trusted Platform Module TPM, Trusted Cryptographic Module TCM, Trusted Platform Control Module TPCM, so on and so forth. However, current applications calling for trusted functions have to use either the user-space trusted interfaces e.g., Trusted Software Stack TSS API or to implement customized APIs on top of the trusted hardware driver; both of them are well known of steep learning curve, which indicates error prone and low-efficient development and complex maintenance for the application of trusted software. This paper presents a new trusted encapsulation architecture and the proof-of-concept system with the aim to mitigate the gap between the current obscure trusted APIs and the actual trusted applications for trusted software development. Our system can provide high-level and much simplified trusted transaction interfaces for user applications, which can rapidly reduce the development and maintenance work for the developers and users without too much performance costs. We also present a secure remote login use-case using mainly the binding and unbinding trusted functions of our trusted encapsulation architecture.

Security issues have become a significant barrier to the adoption of cloud computing services. Most existing security enhancements lack a well defined Root-of-Trust (RoT). Models for Trusted Clouds have been proposed, which establish RoT inside the cloud and vouch for the trustworthiness of the cloud services. However, these are often impractical due to cloud’s dynamics and complexity. In this paper, we present the NeuronVisor, an abstract Cloud Root-of-Trust (cRoT) framework. NeuronVisor enforces decentralized attestations to capture trust dependency among interacting software components inside the cloud, and determines a single cRoT for each cloud application. This cRoT hides the cloud’s internal by presenting a uniform interface for attesting to the trustworthiness of the entire cloud application and all its dependent services inside the cloud (the Cloud TCB). Our simulations show that, for more than 98 % times, one interrogation to the dynamically formed cRoT is able to identify the properties of more than 90 % of the nodes hosting a cloud application and its cloud TCB. Meanwhile, NeuronVisor achieves higher fault detection rate than the prevalent centralized cloud attestation scheme (CEN). It still achieves the same fault detection rate with CEN even when 90 % of the NeuronVisors are constantly tampered with and maliciously collaborating with each other.KeywordsVirtual MachineCloud ServiceConnection StrengthTrust InformationLayer ServiceThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

When a fault is detected in the composition of software components the question arises how to locate a faulty component as well as a faulty instruction within the component. In this paper, we consider a practical approach by calculating how many times a component is traversed by test cases which have expected output responses and by test cases which have unexpected output responses. The obtained integers are weighted and a component for which the maximum value is obtained is faulty with a high probability. As a case study, we consider a collection of array sorting methods. We mutate some instructions and apply different test cases. The obtained results illustrate that a proposed approach is promising.

The proliferation of devices for the Internet of Things (IoT) and their implication in many activities of our lives have led to a considerable increase in concern about the security of these devices, posing a double challenge for designers and developers of products. On the one hand, the design of new security primitives, suitable for resource-limited devices, can facilitate the inclusion of mechanisms and protocols to ensure the integrity and privacy of the data exchanged over the Internet. On the other hand, the development of techniques and tools to evaluate the quality of the proposed solutions as a step prior to their deployment, as well as to monitor their behavior once in operation against possible changes in operating conditions arising naturally or as a consequence of a stress situation forced by an attacker. To address these challenges, this paper first describes the design of a security primitive that plays an important role as a component of a hardware-based root of trust, as it can act as a source of entropy for True Random Number Generation (TRNG) or as a Physical Unclonable Function (PUF) to facilitate the generation of identifiers linked to the device on which it is implemented. The work also illustrates different software components that allow carrying out a self-assessment strategy to characterize and validate the performance of this primitive in its dual functionality, as well as to monitor possible changes in security levels that may occur during operation as a result of device aging and variations in power supply or operating temperature. The designed PUF/TRNG is provided as a configurable IP module, which takes advantage of the internal architecture of the Xilinx Series-7 and Zynq-7000 programmable devices and incorporates an AXI4-based standard interface to facilitate its interaction with soft- and hard-core processing systems. Several test systems that contain different instances of the IP have been implemented and subjected to an exhaustive set of on-line tests to obtain the metrics that determine its quality in terms of uniqueness, reliability, and entropy characteristics. The results obtained prove that the proposed module is a suitable candidate for various security applications. As an example, an implementation that uses less than 5% of the resources of a low-cost programmable device is capable of obfuscating and recovering 512-bit cryptographic keys with virtually zero error rate.

Software development is rarely an individual effort and generally involves teams of developers collaborating to generate good reliable code. Among the software code there exist technical dependencies that arise from software components using services from other components. The different ways of assigning the design, development, and testing of these software modules to people can cause various coordination problems among them. We claim that the collaboration of the developers, designers and testers must be related to and governed by the technical task structure. These collaboration practices are handled in what we call Socio-Technical Patterns. The TESNA project (Technical Social Network Analysis) we report on in this paper addresses this issue. We propose a method and a tool that a project manager can use in order to detect the socio-technical coordination problems. We test the method and tool in a case study of a small and innovative software product company.

A Physical Unclonable Function (PUF) is a physical system that leverages manufacturing process variations to generate unclonable and inherent instance-specific measurements of physical objects. PUF is equivalent to human biometrics in many ways where each human has a unique fingerprint. PUF can securely generate unique and unclonable signatures that allow PUF to bootstrap the implementation of various physical security issues. In this thesis, we discuss PUFs, extend it to a novel SW-PUF, and explore some techniques to utilize it in security applications. We first present the "SW-PUF" - basic building block of this thesis, a novel PUF design that measures processor chip ALU silicon biometrics in a manner similar to all PUFs. Additionally, it composes the silicon measurement with the data-dependent delay of a particular program instruction in a way that is difficult to decompose through a mathematical model. We then implement the proposed PUF to solve various security issues for applications such as Software Protection and Trusted Computing. We prove that the SW-PUF can provide a more robust root of trust for measurement than the existing trusted platform module (TPM). Second, we present the "Reversible SW-PUF", a novel PUF design based on the SW-PUF that is capable of computing partial inputs given its outputs. Given the random output signature of specific instruction in a specific basic block of the program, only the computing platform that originally computed the instruction can accurately regenerate the inputs of the instruction correctly within a certain number of bits. We then implement the Reversible SW-PUF to provide a verifiable computation method. Our scheme links the outsourced software with the cloud-node hardware to provide proof of the computational integrity and the resultant correctness of the results with high probability. Finally, we employ the SW-PUF and the Reversible SW-PUF to provide a trust attribute for data on the Internet of Thing (IoT) systems by combining data provenance and privacy-preserving methods. In our scheme, an IoT server can ensure that the received data comes from the IoT device that owns it. In addition, the server can verify the integrity of the data by validating the provenance metadata for data creation and modification.

This paper attempts to propose a scheme to characterize non-functional security properties that are embedded with the functionality of software components. The security properties are attached with various aspects of a component such as resource allocation, user data protection, communication, and so on.In this paper, we are particularly interested in characterizing the user data protection of software components. It is often reported that software components usually suffer from security and reliability problems. It is now widely recognized that characterization of security properties of software component is an important issue to boost the confidence and trust on component technology.To address this issue, the characterization of security properties of component is the first challenging step. The work proposed in this paper is partially based on the functional requirements defined in Common Criteria for information Technology Security Evaluation endorsed by NIST. The applicability of the proposed scheme is demonstrated with a simple example.

Conventional wisdom, that smaller components contain proportionately fewer faults, may be wrong. This author found that medium-sized components were proportionately more reliable than large or small ones. Moreover, he says, there may be limits on the fault density we can achieve.

Transistor budgets have been increasing at a very fast pace in the last years. This increasing transistor density will lead next generation processors to have a billion transistors available. It is the task of the computer architect to find the best way to use them.Out of order superscalar processors exploit parallelism at the finer grain, exploiting Instruction Level Parallelism (ILP). They issue multiple instructions per cycle, often in an order other than the specified by the programmer, using branch prediction and other speculative execution techniques in order to increase the available parallelism.Very Long Instruction Word (VLIW) processors also exploit parallelism at the instruction level, but they mostly rely on the compiler to detect the available parallelism. This increased compiler role allows a simpler design, and can be run at a faster clock rate, compensating for the loss of ILP.Chip Multiprocessors (CMP) join several narrow superscalar/VLIW components into a single processor, and mostly rely on the Thread Level Parallelism (TLP) for performance. The small and simple components can also run at a faster clock rate compensating for the loss of ILP, and significantly increasing throughput.Simultaneous Multithreaded (SMT) processors are based on wide superscalars, and exploit both ILP and TLP by issuing instructions from several different threads to the same pipeline, obtaining the benefits of TLP without sacrificing the ILP on single-threaded applications.For each of these options we will need to find the best balance between performance, design complexity, and power consumption among other factors. Also, the frontiers between them are not clear, and many intermediate design points can be found which leads to better/simpler/cheaper processors for the next generation of high performance computers.

In combinatorial optimization, a popular approach toNP-hard problems is the design of approximation algorithms. These algorithms typically run in polynomial time and are guaranteed to produce a solution which is within a known multiplicative factor of optimal. Unfortunately, the known factor is often known to be large in pathological instances. Conventional wisdom holds that, in practice, approximation algorithms will produce solutions closer to optimal than their proven guarantees. In this paper, we use the rigorous-analysis-of-heuristics framework to investigate this conventional wisdom.We analyze the performance of 3 related approximation algorithms for the uncapacitated facility location problem (from [Jain, Mahdian, Markakis, Saberi, Vazirani, 2003] and [Mahdian, Ye, Zhang, 2002]) when each is applied to an instances created by placing n points uniformly at random in the unit square. We find that, with high probability, these 3 algorithms do not find asymptotically optimal solutions, and, also with high probability, a simple plane partitioning heuristic does find an asymptotically optimal solution.

Administration and deployment of software systems become increasingly complex. This complexity results from the need of uniform access to applications from heterogeneous terminals through different communication infrastructures. Moreover, applications consists in complex architectures of lot of small components connected together. A first step to simplify deployment is to have an unified and abstract model for representing deployment dependencies and managing them properly. Therefore, we propose here a deployment model and a conceptual foundation for component installation. Installation dependencies and installation rules are expressed in a logic language.

Organic solar cells (OSCs) can achieve greatly improved power conversion efficiency (PCE) by incorporating suitable additives in active layers. Their structure design often faces the challenge of operation generality for more binary blends. Herein, a simple dithieno[3,2-b:2',3'-d]pyrrole-rhodanine molecule (DR8) featuring high compatibility with polymer donor PM6 is developed as a cost-effective third component. By employing classic ITIC-like ITC6-4Cl and Y6 as model nonfullerene acceptors (NFAs) in PM6-based binary blends, DR8 added PM6:ITC6-4Cl blends exhibit significantly promoted energy transfer and exciton dissociation. The PM6:ITC6-4Cl:DR8 (1:1:0.1, weight ratio) OSCs contribute an exciting PCE of 14.94% in comparison to host binary devices (13.52%), while PM6:Y6:DR8 (1:1.2:0.1) blends enable 16.73% PCE with all simultaneously improved photovoltaic parameters. To the best of the knowledge, this performance is among the best for ternary OSCs with simple small molecular third components in the literature. More importantly, DR8-added ternary OSCs exhibit much improved device stability against thermal aging and light soaking over binary ones. This work provides new insight on the design of efficient third components for OSCs.

8 - Manual cutting equipment in textile cutting operations

We are currently exploring and developing a new statistical mechanics approach to designing self organizing and self assembling systems that is unique to SNL. The primary application target for this ongoing research is the development of new kinds of nanoscale components and hardware systems. However, a surprising out of the box connection to software development is emerging from this effort. With some amount of modification, the collective behavior physics ideas for enabling simple hardware components to self organize may also provide design methods for a new class of software modules. Large numbers of these relatively small software components, if designed correctly, would be able to self assemble into a variety of much larger and more complex software systems. This self organization process would be steered to yield desired sets of system properties. If successful, this would provide a radical (disruptive technology) path to developing complex, high reliability software unlike any known today. The special work needed to evaluate this high risk, high payoff opportunity does not fit well into existing SNL funding categories, as it is well outside of the mainstreams of both conventional software development practices and the nanoscience research area that spawned it. We proposed a small LDRD effort aimed at appropriately generalizing these collective behavior physics concepts and testing their feasibility for achieving the self organization of large software systems. Our favorable results motivate an expanded effort to fully develop self-organizing software as a new technology.