20 research outputs found
Recommended from our members
Termination-insensitive noninterference leaks more than just a bit
Current tools for analysing information flow in programs build upon ideas going back to Denning's work from the 70's. These systems enforce an imperfect notion of information flow which has become known as termination-insensitive noninterference. Under this version of noninterference, information leaks are permitted if they are transmitted purely by the program's termination behaviour (i.e., whether it terminates or not). This imperfection is the price to pay for having a security condition which is relatively liberal (e.g. allowing while-loops whose termination may depend on the value of a secret) and easy to check. But what is the price exactly? We argue that, in the presence of output, the price is higher than the “one bit” often claimed informally in the literature, and effectively such programs can leak all of their secrets. In this paper we develop a definition of termination-insensitive noninterference suitable for reasoning about programs with outputs. We show that the definition generalises “batch-job” style definitions from the literature and that it is indeed satisfied by a Denning-style program analysis with output. Although more than a bit of information can be leaked by programs satisfying this condition, we show that the best an attacker can do is a brute-force attack, which means that the attacker cannot reliably (in a technical sense) learn the secret in polynomial time in the size of the secret. If we further assume that secrets are uniformly distributed, we show that the advantage the attacker gains when guessing the secret after observing a polynomial amount of output is negligible in the size of the secret
Facilitating the Implementation of Distributed Systems with Heterogeneous Interactions
International audienceWe introduce HDBIP an extension of the Behavior Interaction Priority (BIP) framework. BIP is a component-based framework with a rigorous operational semantics and high-level and expressive interaction model. HDBIP extends BIP interaction model by allowing heterogeneous interactions targeting distributed systems. HDBIP allows both multiparty and direct send/receive interactions that can be directly mapped to an underlying communication library. Then, we present a correct and efficient code generation from HDBIP to C++ implementation using Message Passing Interface (MPI). We present a non-trivial case study showing the effectiveness of HDBIP
Replicating Web Services for Scalability
Abstract. Web service instances are often replicated to allow service provision to scale to support larger population sizes of users. However, such systems are difficult to analyse because the scale and complexity inherent in the system itself poses challenges for accurate qualitative or quantitative modelling. We use two process calculi cooperatively in the analysis of an example Web service replicated across many servers. The SOCK calculus is used to model service-oriented aspects closely and the PEPA calculus is used to analyse the performance of the system under increasing load.
Robust Contract Evolution in a TypeSafe MicroServices Architecture
Microservices architectures allow for short deployment cycles and immediate
effects but offer no safety mechanisms when service contracts need to be
changed. Maintaining the soundness of microservice architectures is an
error-prone task that is only accessible to the most disciplined development
teams. We present a microservice management system that statically verifies
service interfaces and supports the seamless evolution of compatible
interfaces. We define a compatibility relation that captures real evolution
patterns and embodies known good practices on the evolution of interfaces.
Namely, we allow for the addition, removal, and renaming of data fields of a
producer module without breaking or needing to upgrade consumer services. The
evolution of interfaces is supported by runtime generated proxy components that
dynamically adapt data exchanged between services to match with the statically
checked service code.The model was instantiated in a core language whose
semantics is defined by a labeled transition system and a type system that
prevents breaking changes from being deployed. Standard soundness results for
the core language entail the existence of adapters, hence the absence of
adaptation errors and the correctness of the management model. This adaptive
approach allows for gradual deployment of modules, without halting the whole
system and avoiding losing or misinterpreting data exchanged between system
nodes. Experimental data shows that an average of 69% of deployments that would
require adaptation and recompilation are safe under our approach
Microservice Dynamic Architecture-Level Deployment Orchestration
International audienceWe develop a novel approach for run-time global adaptation of microservice applications, based on synthesis of architecture-level reconfiguration orchestrations. More precisely, we devise an algorithm for automatic reconfiguration that reaches a target system Maximum Computational Load by performing optimal deployment orchestrations. To conceive and simulate our approach, we introduce a novel integrated timed architectural modeling/execution language based on an extension of the actor-based object-oriented Abstract Behavioral Specification (ABS) language. In particular, we realize a timed extension of SmartDeployer, whose ABS code annotations make it possible to express architectural properties. Our Timed SmartDeployer tool fully integrates time features of ABS and architectural annotations by generating timed deployment orchestrations. We evaluate the applicability of our approach on a realistic microservice application taken from the literature: an Email Pipeline Processing System. We prove its effectiveness by simulating such an application and by comparing architecture-level reconfiguration with traditional local scaling techniques (which detect scaling needs and enact replications at the level of single microservices). Our comparison results show that our approach avoids cascading slowdowns and consequent increased message loss and latency, which affect traditional local scaling
Sized Types with Usages for Parallel Complexity of Pi-Calculus Processes
We address the problem of analysing the complexity of concurrent programs written in Pi-calculus. We are interested in parallel complexity, or span, understood as the execution time in a model with maximal parallelism. A type system for parallel complexity has been recently proposed by the first two authors but it is too imprecise for non-linear channels and cannot analyse some concurrent processes. Aiming for a more precise analysis, we design a type system which builds on the concepts of sized types and usages. The sized types allow us to parametrize the complexity by the size of inputs, and the usages allow us to achieve a kind of rely-guarantee reasoning on the timing each process communicates with its environment. We prove that our new type system soundly estimates the parallel complexity, and show through examples that it is often more precise than the previous type system of the first two authors
Choral: Object-Oriented Choreographic Programming
We present Choral, the first choreographic programming language based on
mainstream abstractions. The key idea in Choral is a new notion of data type,
which allows for expressing that data is distributed over different roles. We
use this idea to reconstruct the paradigm of choreographic programming through
object-oriented abstractions. Choreographies are classes, and instances of
choreographies are objects with states and behaviours implemented
collaboratively by roles.
Choral comes with a compiler that, given a choreography, generates an
implementation for each of its roles. These implementations are libraries in
pure Java, whose types are under the control of the Choral programmer.
Developers can then modularly compose these libraries in their own programs, in
order to participate correctly in choreographies. Choral is the first
incarnation of choreographic programming offering such modularity, which
finally connects more than a decade of research on the paradigm to practical
software development.
The integration of choreographic and object-oriented programming yields other
powerful advantages, where the features of one paradigm benefit the other in
ways that go beyond the sum of the parts. The high-level abstractions and
static checks from the world of choreographies can be used to write concurrent
and distributed object-oriented software more concisely and correctly. We
obtain a much more expressive choreographic language from object-oriented
abstractions than in previous work. For example, object passing makes Choral
the first higher-order choreographic programming language, whereby
choreographies can be parameterised over other choreographies without any need
for central coordination. Together with subtyping and generics, this allows
Choral to elegantly support user-defined communication mechanisms and
middleware
Actor programming with static guarantees
This thesis discusses two methodologies for applying type discipline to concurrent programming with actors: process types, and session types. A system based on each of the two is developed, and used as the basis for a comprehensive overview of process- and session- type merits and limitations. In particular, we analyze the trade-offs of the two approaches with regard to the expressiveness of the resulting calculi, versus the nature of the static guarantees offered. The first system discussed is based on the notion of a \emph{typestate}, that is, a view of an actor's internal state that can be statically tracked. The typestates used here capture what each actor handle \emph{may} be used for, as well as what it \emph{must} be used for. This is done by associating two kinds of tokens with each actor handle: tokens of the first kind are consumed when the actor receives a message, and thus dictate the types of messages that can be sent through the handle; tokens of the second kind dictate messaging obligations, and the type system ensures that related messages have been sent through the handle by the end of its lifetime. The next system developed here adapts session types to suit actor programming.
Session types come from the world of process calculi, and are a means to statically check the messaging taking place over communication channels against a pre-defined protocol. Since actors do not use channels, one needs to consider pairs of actors as participants in multiple, concurrently executed---and thus interleaving---protocols. The result is a system with novel, parameterized type constructs to capture communication patterns that prior work cannot handle, such as the sliding window protocol. Although this system can statically verify the implementation of complicated messaging patterns, it requires deviations from industry-standard programming models---a problem that is true for all session type systems in the literature. This work argues that the typestate-based system, while not enforcing protocol fidelity as the session-inspired one does, is nevertheless more suitable for model actor calculi adopted by practical, already established frameworks such as Erlang and Akka