Secure shared data-space coordination languages: A process algebraic survey
---
paper_title: Generative communication in Linda

paper_content:

Generative communication is the basis of a new distributed programming langauge that is intended for systems programming in distributed settings generally and on integrated network computers in particular. It differs from previous interprocess communication models in specifying that messages be added in tuple-structured form to the computation environment, where they exist as named, independent entities until some process chooses to receive them. Generative communication results in a number of distinguishing properties in the new language, Linda, that is built around it. Linda is fully distributed in space and distributed in time; it allows distributed sharing, continuation passing, and structured naming. We discuss these properties and their implications, then give a series of examples. Linda presents novel implementation problems that we discuss in Part II. We are particularly concerned with implementation of the dynamic global name space that the generative communication model requires.
---
paper_title: LIME: a middleware for physical and logical mobility

paper_content:

LIME is a middleware supporting the development of applications that exhibit physical mobility of hosts, logical mobility of agents, or both. LIME adapts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible, persistent tuple space, is represented in LIME by transient sharing of the tuple spaces carried by each individual mobile unit. Linda tuple spaces are also extended with a notion of location and with the ability to react to a given state. The hypothesis underlying our work is that the resulting model provides a minimalist set of abstractions that enable rapid and dependable development of mobile applications. In this paper, we illustrate the model underlying LIME, present its current design and implementation, and discuss initial lessons learned in developing applications that involve physical mobility.
---
paper_title: KLAIM: A Kernel Language for Agents Interaction and Mobility

paper_content:

We investigate the issue of designing a kernel programming language for mobile computing and describe KLAIM, a language that supports a programming paradigm where processes, like data, can be moved from one computing environment to another. The language consists of a core Linda with multiple tuple spaces and of a set of operators for building processes. KLAIM naturally supports programming with explicit localities. Localities are first-class data (they can be manipulated like any other data), but the language provides coordination mechanisms to control the interaction protocols among located processes. The formal operational semantics is useful for discussing the design of the language and provides guidelines for implementations. KLAIM is equipped with a type system that statically checks access right violations of mobile agents. Types are used to describe the intentions (read, write, execute, etc.) of processes in relation to the various localities. The type system is used to determine the operations that processes want to perform at each locality, and to check whether they comply with the declared intentions and whether they have the necessary rights to perform the intended operations at the specific localities. Via a series of examples, we show that many mobile code programming paradigms can be naturally implemented in our kernel language. We also present a prototype implementation of KLAIM in Java.
---
paper_title: LIME: a middleware for physical and logical mobility

paper_content:

LIME is a middleware supporting the development of applications that exhibit physical mobility of hosts, logical mobility of agents, or both. LIME adapts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible, persistent tuple space, is represented in LIME by transient sharing of the tuple spaces carried by each individual mobile unit. Linda tuple spaces are also extended with a notion of location and with the ability to react to a given state. The hypothesis underlying our work is that the resulting model provides a minimalist set of abstractions that enable rapid and dependable development of mobile applications. In this paper, we illustrate the model underlying LIME, present its current design and implementation, and discuss initial lessons learned in developing applications that involve physical mobility.
---
paper_title: WSSecSpaces: a secure data-driven coordination service for Web Services applications

paper_content:

Web Services standards and protocols (WSDL, UDDI, SOAP, etc.) are the basis of a novel technology supporting Web based applications. Web Services are components offering ports at which service invocations can be sent using XML-based protocols. The tools currently proposed for specifying and programming the interdependencies among Web Services (BPEL, BizTalk, etc.) support the description of the flow of service invocation needed among collaborating Web Services in order to complete a specific task. In this paper we discuss the design and the implementation of a higher-level interaction model for Web Services that follows the tradition of data-driven coordination: Web Services do not coordinate via direct service invocation, but their interaction is mediated by a coordination space where shared data are stored and retrieved. Moreover, our proposal extends the traditional data-driven coordination model with a more sophisticated pattern matching mechanism that supports a controlled access to the shared data.
---
paper_title: KLAIM: A Kernel Language for Agents Interaction and Mobility

paper_content:

We investigate the issue of designing a kernel programming language for mobile computing and describe KLAIM, a language that supports a programming paradigm where processes, like data, can be moved from one computing environment to another. The language consists of a core Linda with multiple tuple spaces and of a set of operators for building processes. KLAIM naturally supports programming with explicit localities. Localities are first-class data (they can be manipulated like any other data), but the language provides coordination mechanisms to control the interaction protocols among located processes. The formal operational semantics is useful for discussing the design of the language and provides guidelines for implementations. KLAIM is equipped with a type system that statically checks access right violations of mobile agents. Types are used to describe the intentions (read, write, execute, etc.) of processes in relation to the various localities. The type system is used to determine the operations that processes want to perform at each locality, and to check whether they comply with the declared intentions and whether they have the necessary rights to perform the intended operations at the specific localities. Via a series of examples, we show that many mobile code programming paradigms can be naturally implemented in our kernel language. We also present a prototype implementation of KLAIM in Java.
---
paper_title: LIME: a middleware for physical and logical mobility

paper_content:

LIME is a middleware supporting the development of applications that exhibit physical mobility of hosts, logical mobility of agents, or both. LIME adapts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible, persistent tuple space, is represented in LIME by transient sharing of the tuple spaces carried by each individual mobile unit. Linda tuple spaces are also extended with a notion of location and with the ability to react to a given state. The hypothesis underlying our work is that the resulting model provides a minimalist set of abstractions that enable rapid and dependable development of mobile applications. In this paper, we illustrate the model underlying LIME, present its current design and implementation, and discuss initial lessons learned in developing applications that involve physical mobility.
---
paper_title: Secure Sharing of Tuple Spaces in Ad Hoc Settings

paper_content:

Abstract Security is emerging as a growing concern throughout the distributed computing community. Typical solutions entail specialized infrastructure support for authentication, encryption and access control. Mobile applications executing over ad hoc wireless networks present designers with a rather distinct set of security requirements. A totally open setting and limited resources call for lightweight and highly decentralized security solutions. In this paper we propose an approach that relies on extending an existing coordination middleware for mobility ( Lime ). The need to continue to offer a very simple model of coordination that assures rapid software development led to limiting extensions solely to password protected tuple spaces and per tuple access control. Password distribution and security are relegated to the application realm. Host level security is ensured by the middleware design and relies on standard support provided by the Java system. Secure interactions among agents across hosts are accomplished by careful exploitation of the interceptor pattern and the use of standard encryption. The paper explains the design strategy used to add security support in Lime and its implications for the development of mobile applications over ad hoc networks.
---
paper_title: COORDINATING PROCESSES WITH SECURE SPACES

paper_content:

The Linda shared space model and its derivatives provide great flexibility for building parallel and distributed applications composed of independent processes. However, the shared space model does not provide protection against untrustworthy processes. Linda processes communicate by reading and writing messages in a globally visible data space, so a malicious process can launch any number of security attacks. This paper presents the design of a new coordination model which extends Linda with fine-grained access control. The semantics of the model is presented in the context of a process calculus. A prototype of our model, called SECOS, has been implemented in JAVA.
---
paper_title: Formal Specification and Enactment of Security Policies through Agent Coordination Contexts

paper_content:

Abstract Our research moves from three fundamental considerations that concern the modelling and engineering of complex systems. First, organization, coordination and security are strictly related issues that should be modelled in a uniform and coherent framework. Second, models, technologies and methodologies should come hand in hand, so that abstractions used in the analysis and design stages should be still “alive and kicking” at development and execution time. Third, the general non-formalisability of complex systems should not prevent us from using formal tools whenever useful, such as in proving or ensuring properties of limited but meaningful portions of a system. By focussing on multi-agent systems, we discuss the notion of Agent Coordination Context (ACC) as an abstraction that (i) works as an organization and security abstraction, (ii) integrates well with abstractions provided by coordination infrastructures, and (iii) covers the engineering process from design to deployment. In particular, in this paper we study the syntax and semantics of a language for ACCs specification, exploiting typical process algebra techniques. Accordingly, we show that process algebras are a suitable tool for both specification and enactment of security and coordination policies through ACCs.
---

Title: Secure Shared Data-Space Coordination Languages: A Process Algebraic Survey

Section 1: Introduction
Description 1: Provide an overview of the need for secure coordination models and languages in new networking technologies and distributed applications, including the significance of ensuring security properties.

Section 2: The Linda Coordination Model
Description 2: Describe the basic Linda coordination model, including its primitives and the formal definitions of tuples and templates.

Section 3: Security Threats
Description 3: Discuss the main security threats that arise when using the Linda coordination model in open and untrusted environments, providing real-world examples.

Section 4: Linda with Labels
Description 4: Explain the extension of Linda with labels for access control, and present the taxonomy of solutions following knowledge-driven and entity-driven approaches for adding security.

Section 5: Knowledge-Driven Mechanisms
Description 5: Describe the knowledge-driven approach for achieving secure coordination, including formal definitions and semantics.

Section 6: Entity-Driven Mechanisms
Description 6: Explain the entity-driven approach for secure coordination, with formal definitions and semantics tailored to managing entity-specific access control.

Section 7: Linda-Like Languages for Untrusted Environments
Description 7: List and describe various Linda-like languages designed for untrusted environments, detailing their specific security features and access control mechanisms.

Section 8: KLAIM
Description 8: Provide an in-depth look at the KLAIM language, explaining its entity-driven security approach and its application for secure group communication.

Section 9: Secure Lime
Description 9: Discuss the Secure Lime proposal, detailing its implementation of password-based access control mechanisms at the tuple and tuple space level.

Section 10: SecOS
Description 10: Explain the SecOS language, focusing on its knowledge-driven approach utilizing symmetric and asymmetric keys for access control.

Section 11: SecSpaces
Description 11: Describe SecSpaces, highlighting its refined access control policies for read and input operations, and its model for single tuple space protection.

Section 12: Conclusion and Related Work
Description 12: Summarize the survey, comparing the discussed languages and their security mechanisms, and list related works that follow different approaches to secure shared data-space coordination languages.