A pi-calculus with dynamic typing (original) (raw)

Communication Errors in the pi-Calculus are Undecidable

1999

We present an undecidability proof of the notion of communication errors in the polyadic #-calculus. The demonstration follows a general pattern of undecidability proofs---reducing a well-known undecidable problem to the problem in question. We make use of an encoding of the #-calculus into the #-calculus to show that the decidability of communication errors would solve the problem of deciding whether a lambda term has a normal form. Introduction. The detection of communication errors in process calculi is crucial to ensure the safety of concurrent programs, i.e., the absence of run-time errors. The usual approach is to develop a type system, which is sound with respect to the notion of error, but, in general, not complete. The notions of communication errors are usually undecidable, and this makes the type approach relevant. For the polyadic #-calculus [8] this is also the case. Herein we show that the notion of communication errors in the polyadic #-calculus is undecidable. The pr...

Information flow vs. resource access in the asynchronous pi-calculus

ACM Transactions on Programming Languages and Systems, 2002

We propose an extension of the asynchronous π-calculus in which a variety of security properties may be captured using types. These are an extension of the input/output types for the π-calculus in which I/O capabilities are assigned specific security levels. The main innovation is a uniform typing system that, by varying slightly the allowed set of types, captures different notions of security.We first define a typing system that ensures that processes running at security level σ cannot access resources with a security level higher than σ. The notion of access control guaranteed by this system is formalized in terms of a Type Safety Theorem.We then show that, by restricting the allowed types, our system prohibits implicit information flow from high-level to low-level processes. We prove that low-level behavior can not be influenced by changes to high-level behavior. This is formalized as a noninterference theorem with respect to may testing.

Communication errors in the -calculus are undecidable

Information Processing Letters, 1999

We present an undecidability proof of the notion of communication errors in the polyadic π-calculus. The demonstration follows a general pattern of undecidability proofs-reducing a well-known undecidable problem to the problem in question. We make use of an encoding of the λ-calculus into the π-calculus to show that the decidability of communication errors would solve the problem of deciding whether a lambda term has a normal form.

Static Analysis for the π-Calculus with Applications to Security

Information and Computation, 2001

Control Flow Analysis is a static technique for predicting safe and computable approximations to the set of values that the objects of a program may assume during its execution. We present an analysis for the π-calculus that shows how names will be bound to actual channels at run time. The result of our analysis establishes a super-set of the set of channels to which a given name may be bound and of the set of channels that may be sent along a given channel. Besides a set of rules that permits one to validate a given solution, we also offer a constructive procedure that builds solutions in low polynomial time. Applications of our analysis include establishing two simple security properties of processes. One example is that P has no leaks: P offers communication to the external environment through public channels only and confines its secret channels within itself. The other example is connected to the no read-up/no write-down property of Bell and LaPadula: once processes are given levels of security clearance, we check that a process at a high level never sends channels to processes at a lower level. C

Formalizing process algebraic verifications in the calculus of constructions

Formal Aspects of Computing, 1997

This paper reports on the rst steps towards the formal veri cation of correctness proofs of real-life protocols in process algebra. We show that proofs can be veri ed, and partly constructed, by a general purpose proof checker. The process algebra we use is CRL, ACP augmented with data, which is small enough to make the veri cation feasible, and at the same time expressive enough for the speci cation of real-life protocols. The proof checker we use is Coq, which is based on the Calculus of Constructions, an extension of simply typed lambda calculus. The focus is on the translation of the proof theory of CRL and CRL-speci cations to Coq. As a case study, we veri ed the Alternating Bit Protocol.

On the Expressiveness of Symmetric Communication

Lecture Notes in Computer Science, 2016

The expressiveness of communication primitives has been explored in a common framework based on the π-calculus by considering four features: synchronism, arity, communication medium, and pattern-matching. These all assume asymmetric communication between input and output primitives, however some calculi consider more symmetric approaches to communication such as fusion calculus and Concurrent Pattern Calculus. Symmetry can be considered either as supporting exchange of information between an action and co-action, or as unification of actions. By means of possibility/impossibility of encodings, this paper shows that the exchange approach is related to, or more expressive than, many previously considered languages. Meanwhile, the unification approach is more expressive than some, but mostly unrelated to, other languages.

The logic of message passing

Corr, 2007

Message passing is a key ingredient of concurrent programming. The purpose of this paper is to describe the equivalence between the proof theory, the categorical semantics, and term calculus of message passing. In order to achieve this we introduce the categorical notion of a linear actegory and the related polycategorical notion of a poly-actegory. Not surprisingly the notation used for the term calculus borrows heavily from the (synchronous) pi-calculus. The cut elimination procedure for the system provides an operational semantics.

Secure implementations of typed channel abstractions

ACM SIGPLAN Notices, 2007

The challenges hidden in the implementation of high-level process calculi into low-level environments are well understood [3]. This paper develops a secure implementation of a typed pi calculus, in which capability types are employed to realize the policies for the access to communication channels. Our implementation compiles high-level processes of the pi-calculus into low-level principals of a cryptographic process calculus based on the applied-pi calculus [1]. In this translation, the high-level type capabilities are implemented as term capabilities protected by encryption keys only known to the intended receivers. As such, the implementation is effective even when the compiled, low-level principals are deployed in open contexts for which no assumption on trust and behavior may be made. Our technique and results draw on, and extend, previous work on secure implementation of channel abstractions in a dialect of the join calculus [2]. In particular, our translation preserves the fo...

Correspondence assertions for process synchronization in concurrent communications

Journal of Functional Programming, 2005

High-level specification of patterns of communications such as protocols can be modeled elegantly by means of session types [HVK98]. However, a number of examples suggest that session types fall short when finer precision on protocol specification is required. In order to increase the expressiveness of session types we appeal to the theory of correspondence assertions GJ01b]. The resulting type discipline augments the types of long term channels with effects and thus yields types which may depend on messages read or written earlier within the same session. We prove that evaluation preserves typability and that well-typed processes are safe. Also, we illustrate how the resulting theory allows us to address the shortcomings present in the pure theory of session types. * An extended abstract of this work was presented at the FOCLASA 2003 workshop.

Type-based information flow analysis for the π-calculus

Acta Informatica, 2005

We propose a new type system for information flow analysis for the π-calculus. As demonstrated by recent studies, information about whether each communication succeeds is important for precise information flow analysis for concurrent programs. By collecting such information using ideas of our previous type systems for deadlock/livelock-freedom, our type system can perform more precise analysis for certain communication/synchronization patterns (like synchronization using locks) than previous type systems. Our type system treats a wide range of communication/synchronization primitives in a uniform manner, which enabled development of a clear proof of type soundness and a sound and complete type inference algorithm.