Automated Synthesis of Secure Platform Mappings

TL;DR

This paper presents a formal method for automatically synthesizing platform mappings that preserve security properties from high-level designs to low-level implementations, demonstrated through real-world web protocol case studies.

Contribution

It introduces the problem of property-preserving platform mapping synthesis, formalizes it, and proposes a symbolic constraint search technique with a prototype implementation.

Findings

Successfully synthesized secure mappings for OAuth protocols.

Demonstrated the approach on real-world web authorization protocols.

Validated the effectiveness of the symbolic constraint search method.

Abstract

System development often involves decisions about how a high-level design is to be implemented using primitives from a low-level platform. Certain decisions, however, may introduce undesirable behavior into the resulting implementation, possibly leading to a violation of a desired property that has already been established at the design level. In this paper, we introduce the problem of synthesizing a property-preserving platform mapping: A set of implementation decisions ensuring that a desired property is preserved from a high-level design into a low-level platform implementation. We provide a formalization of the synthesis problem and propose a technique for synthesizing a mapping based on symbolic constraint search. We describe our prototype implementation, and a real-world case study demonstrating the application of our technique to synthesizing secure mappings for the popular web authorization protocols OAuth 1.0 and 2.0.

Figures

Equations

$$\forall t\in T:\neg \exists e\in events(t):\text{writeEve}(\text{secret})\in e$$

$$\displaystyle\left\langle\right\rangle\project A=\left\langle\right\rangle\qquad(\left\langle e\right\rangle\cdot t)\project A=\left\{\begin{array}[]{ll}\left\langle e\cap A\right\rangle\cdot(t\project A)&\text{if}\ e\cap A\neq\emptyset\\ (t\project A)&\text{otherwise}\end{array}\right.$$

$${evts}_{P\parallel Q}=\{e\in E({\alpha }_P\cup {\alpha }_Q)\mid e\cap {\alpha }_P\in {evts}_P\wedge e\cap {\alpha }_Q\in {evts}_Q\wedge cond(e)\}$$

$${beh}_{P\parallel Q}=\{t\in ({evts}_{P\parallel Q}{)}^{\ast }\mid (t\text{project}{\alpha }_P)\in {beh}_P\wedge (t\text{project}{\alpha }_Q)\in {beh}_Q\}$$

$$cond(e)\equiv e\subseteq {\alpha }_P-{\alpha }_Q\vee e\subseteq {\alpha }_Q-{\alpha }_P\vee (\exists a\in e:a\in {\alpha }_P\cap {\alpha }_Q)$$

$${beh}_{P\parallel Q}=\{t\in T({\alpha }_P\cup {\alpha }_Q)\mid$$

$${evts}_{P{\Vert }_{m}Q}=\{e\in E({\alpha }_P\cup {\alpha }_Q)\mid e\cap {\alpha }_P\in {evts}_P\wedge e\cap {\alpha }_Q\in {evts}_Q\wedge$$

$$con{d}^{\prime }(e)\wedge condmap(e,m)\}$$

$$beh(P{\Vert }_{m}Q)=\{t\in (event{s}_{P{\Vert }_{m}Q}{)}^{\ast }\mid (t\text{project}{\alpha }_P)\in P\wedge (t\text{project}{\alpha }_Q)\in Q\}$$

$$con{d}^{\prime }(e)\equiv cond(e)\vee (\exists a\in e\cap {\alpha }_P,\exists b\in e\cap {\alpha }_Q:m(a)=b\vee m(b)=a)$$

$$condmap(e,m)\equiv (\forall a\in e,\forall b\in L:m(a)=b⟹b\in e)$$

$$⟨\{b\},\{a\},\{x\},\{y\},\{x\}⟩\notin {beh}_{P{\Vert }_{m}Q}$$

$$⟨\{b\},\{a,x\},\{y\},\{x\}⟩\in {beh}_{P{\Vert }_{m}Q}$$

$$⟨\{b\},\{x\},\{y\},\{a,x\}⟩\in {beh}_{P{\Vert }_{m}Q}$$

$$\text{Msg}=\{\text{public},\text{secret}\}\text{Key}=\{\text{none},{\text{k}}_{\text{X}},{\text{k}}_{\text{Y}}\}$$

$$L_P=\{\text{writeBob}(\text{public}),\text{writeBob}(\text{secret}),\text{writeEve}(\text{public}),\text{writeEve}(\text{secret})\}$$

$$L_Q=\{\text{encWrite}(\text{secret},\text{none}),\text{encWrite}(\text{secret},{\text{k}}_{\text{X}}),\text{encWrite}(\text{secret},{\text{k}}_{\text{Y}}),$$

$$\text{encWrite}(\text{public},\text{none}),\text{encWrite}(\text{public},{\text{k}}_{\text{X}}),\text{encWrite}(\text{public},{\text{k}}_{\text{Y}})\}$$

$$m_1=$$

$$(\text{writeBob}(\text{public}),\text{encWrite}(\text{public},\text{none})),(\text{writeEve}(\text{public}),\text{encWrite}(\text{public},\text{none}))\}$$

$$e=\{\text{writeBob}(\text{secret}),\text{encWrite}(\text{secret},\text{none})\}$$

$${beh}_P=\{⟨\{b,c\}⟩\}{beh}_Q=\{⟨\{b\}⟩\}{beh}_R=\{⟨\{c\}⟩\}$$

$${beh}_{P\parallel Q}=\{⟨\{b,c\}⟩\}\text{mbox}and{beh}_{(P\parallel Q)\parallel R}=\{⟨\{b,c\}⟩\}$$

$${beh}_{Q\parallel R}=\{⟨\{b\},\{c\}⟩,⟨\{c\},\{b\}⟩\}\text{mbox}and{beh}_{P\parallel (Q\parallel R)}=\varnothing$$

$${beh}_P=\{⟨\{a\}⟩\}{beh}_Q=\{⟨\{b\}⟩\}beh(R)=\{⟨\{c\}⟩\}$$

$$beh(Q{\Vert }_{m_2}R)=\{⟨\{b\},\{c\}⟩,⟨\{c\},\{b\}⟩\}$$

$$beh(P{\Vert }_{m_1}(Q{\Vert }_{m_2}R))=\{⟨\{a,b\},\{c\}⟩,⟨\{c\},\{a,b\}⟩\}$$

$$beh(P{\Vert }_{m_1}Q)=\{⟨a,b⟩\}beh((P{\Vert }_{m_1}Q){\Vert }_{m_2}R)=\{⟨\{a,b,c\}⟩\}$$

$$sem(\varphi ,L)=\{\begin{array}{ll}\{t\in T(L)|sat(t,\varphi )\}& \text{if }{L}_{\varphi }\subseteq L\\ \text{undefined}& \text{ otherwise}\end{array}$$

$$X=sem(\varphi ,\alpha (P))X^{\prime }=sem(\varphi ,\alpha (P{\Vert }_{m}Q))$$

$$sat(t,\varphi )⟺\varphi (t)$$

$$P\models \varphi ⟺P\subseteq sem(\varphi ,\alpha (P))$$

$$\neg \exists e\in events(t):\text{writeEve}(\text{secret})\in e$$

$$⟨\{\text{writeBob(secret)}\},\{\text{writeEve(public)}\}⟩\in sem(\varphi ,\alpha (P))$$

Full text

1 Introduction

When building a complex software system, one begins by coming up with an abstract design, and then constructs an implementation that conforms to this design. In practice, there are rarely enough time and resources available to build an implementation from scratch, and so this process often involves reuse of an existing platform—a collection of generic components, data structures, and libraries that are used to build an application in a particular domain.

The benefits of reuse also come with potential risks. A typical platform exhibits its own complex behavior, including subtle interactions with the environment that may be difficult to anticipate and reason about. Typically, the developer must work with the platform as it exists, and is rarely given the luxury of being able to modify it and remove unwanted features. For example, when building a web application, a developer must work with a standard browser and take into account all its features and security vulnerabilities. As a result, achieving an implementation that perfectly conforms to the design—in the traditional notion of behavioral refinement [25]—may be too difficult in practice. Worse, the resulting implementation may not necessarily preserve desirable properties that have already been established at the level of design.

These risks are especially evident in applications where security is a major concern. For example, OAuth 2.0, a popular authorization protocol subjected to rigorous and formal analysis at an abstract level [13, 36, 45], has been shown to be vulnerable to attacks when implemented on a web browser or a mobile device [41, 44, 14]. Many of these vulnerabilities are not due to simple programming errors: They arise from logical flaws that involve a subtle interaction between the protocol logic and the details of the underlying platform. Unfortunately, OAuth itself does not explicitly guard against these flaws, since it is intended to be a generic, abstract protocol that deliberately omits details about potential platforms. On the other hand, anticipating and mitigating against these risks require an in-depth understanding of the platform and security expertise, which many developers do not possess.

This paper proposes an approach to help developers overcome these risks and achieve an implementation that preserves desired properties. In particular, we formulate this task as the problem of automatically synthesizing a property-preserving platform mapping: A set of implementation decisions ensuring that a desired property is preserved from a high-level design into a low-level platform implementation.

Our approach builds on the prior work of Kang et al. [33], which proposes a modeling and verification framework for reasoning about security attacks across multiple levels of abstraction. The central notion in this framework is that of a mapping, which captures a developer’s decisions about how abstract system entities are to be realized in terms of their concrete counterparts. In this paper, we extend the framework with the novel problem of synthesizing a property-preserving mapping, and propose an algorithmic technique for performing this synthesis task.

We have built a prototype implementation of the synthesis technique. Our tool accepts a high-level design model, a desired system property (both specified by the developer), and a model of a low-level platform (built and maintained separately by a domain expert). The tool then produces a mapping (if any) that ensures that the resulting platform implementation preserves the given property. As a case study, we have successfully applied our tool to synthesize property-preserving mappings for two different variants of OAuth implemented on top of HTTP. Our results are promising: The implementation decisions captured by our synthesized mappings describe effective mitigations against some of the common vulnerabilities that have been found in deployed OAuth implementations [41, 44]. The contributions of this paper include:

• •

A formal treatment of mapping, including a correction in the original definition [33] (Section 3);

• •

A formulation of the mapping synthesis problem, a novel approach for ensuring the preservation of a property between a high-level design and its platform implementation (Section 5);

• •

A technique for automatically synthesizing mappings based on symbolic constraint search (Section 6);

• •

A prototype implementation of the synthesis technique, and a real-world case study demonstrating the feasibility of this approach (Section 7).

We conclude with a discussion of related work (Section 8).

2 Running Example

Let us introduce a running example that we will use throughout the paper. Consider the simple model in Figure 1(a), consisting of three interacting processes, Alice, Bob, and Eve. In this system, Alice wishes to communicate messages to Bob and Eve, but is willing to share its secrets only with Bob. Alice has access to two separate communication channels (represented by event labels writeBob and writeEve). Alice behaves as follows: It first non-deterministically selects a message to be sent ($m$) from some set Msg. If the selected message is not a secret (represented by the constant $\textsf{\small{secret}}\in\textsf{\small{Msg}}$), Alice sends $m$ to either Bob or Eve over the corresponding channel (i.e., by performing writeBob or writeEve). If, however, the chosen message $m$ is a secret, Alice sends $m$ only to Bob.

Suppose that Eve is a malicious character whose goal is to learn the secret shared between Alice and Bob. One desirable property of the system is that Eve should never be able to learn the secret. This property can be stated as the following first-order logic formula

[TABLE]

where $T$ is the set of possible system traces, and $events(t)$ returns the set of events in trace $t$111The behavioral semantics will be further explained in Section 3.. In other words, the property states that the system should never enter the SecretLearned state by executing a $\textsf{\small{writeEve}}({\textsf{\small{secret}}})$ event (see Figure 1). It can be observed that the composition of the three processes, $\textsf{\small{Alice}}\parallel\textsf{\small{Bob}}\parallel\textsf{\small{Eve}}$, satisfies this property, since Alice, by design, never sends a secret over the channel to Eve.

Now consider the model in Figure 1(b), which describes communication between a pair of processes over an encrypted public channel (represented by event label $\textsf{\small{encWrite}}(m,k)$, where $m$ is the message being sent, and $k$ is the key used to encrypt the message). Each process is associated with a value called knows, which represents the set of keys that the process has access to. In its behavior, Sender non-deterministically chooses a message and a key to encrypt it with. Receiver, upon receiving the message, is able to read it only if it knows the key $k$ that $m$ is encrypted with, or if $m$ has not been encrypted at all (i.e., $k=\textsf{\small{none}}$). In this particular example, we use the absence of a corresponding transition to model the assumption that Receiver is unable to read message $m$ without knowing the key.

Suppose that we wish to reason about the behavior of the abstract communication system from Figure 1(a) when it is implemented over the public channel in 1(b). Conceptually, implementation involves mapping the elements of the abstract, high-level model into those of the low-level model. The developer’s task is to determine such a mapping, and by doing so resolve various implementation decisions that need to be made. In this toy example, the crucial implementation decision stems from the fact that, while the abstract model provides two separate channels, writeBob and writeEve, the low-level model provides only one channel, encWrite. Therefore, the developer must decide how the abstract events writeBob(m) and writeEve(m) are to be mapped into encWrite(m,k) events. In particular, to ensure the security of the resulting implementation, the developer must answer: Which of the decisions will ensure that secret messages remain protected from Eve in the resulting implementation? In the rest of this paper, we describe how this question can be formulated and tackled as the problem of synthesizing a property-preserving mapping between a pair of models that depict a high-level design and a low-level platform.

3 Mapping Composition

Our synthesis approach builds on the modeling and verification framework proposed in [33], which is designed to allow reasoning about behavior of processes across multiple abstraction layers. In this framework, a trace-based semantic model (based on CSP [26]) is extended to represent events as sets of labels, and includes a new composition operator based on the notion of mappings, which relate event labels from one abstraction layer to another. In this section, we present the essential elements of this framework.

3.1 Denotational Semantics

Events, traces, and processes.

Let $L$ be a potentially infinite set of labels. An event $e$ is a finite, non-empty set of labels: $e\in E(L)=\mathbb{P}(L)-\{\emptyset\}$, where $\mathbb{P}(L)$ is the powerset of $L$, and $\emptyset$ denotes the empty set. Let $S^{*}$ denote the set of all finite sequences of elements of some set $S$. A trace $t$ is a finite sequence of events: $t\in T(L)$, where $T(L)$ is the set of all traces over $L$ (i.e., $T(L)=(E(L))^{*}$). The empty trace is denoted by $\left\langle\right\rangle$, and the trace consisting of a sequence of events $e_{1},e_{2},...$ is denoted $\left\langle e_{1},e_{2},...\right\rangle$. If $t$ and $t^{\prime}$ are traces, then $t\cdot t^{\prime}$ is the trace obtained by concatenating $t$ and $t^{\prime}$. Note that $\left\langle\right\rangle\cdot t=t\cdot\left\langle\right\rangle=t$ for any trace $t$. The events of a trace $t$, written $events(t)$, is the set of all events appearing in $t$. For example, if $t=\left\langle\{a\},\{a,c\},\{b\}\right\rangle$, then $events(t)=\{\{a\},\{a,c\},\{b\}\}$.

Let $t$ be a trace over set of labels $L$, and let $A\subseteq L$ be a subset of $L$. The projection of $t$ onto $A$, denoted $t\project A$, is defined as follows:

[TABLE]

For example, if $t=\left\langle\{a\},\{a,c\},\{b\}\right\rangle$, then $t\project\{a,b\}=\left\langle\{a\},\{a\},\{b\}\right\rangle$ and $t\project\{b,c\}=\left\langle\{c\},\{b\}\right\rangle$.

A process $P$ is defined as a triple $(\alpha,\mathit{evts},\mathit{beh})$. The alphabet $\alpha\subseteq L$ is the set of all labels appearing in $P$, and $\mathit{evts}\subseteq E(\alpha)$ is the set of events that may appear in traces of $P$, which are denoted $\mathit{beh}\subseteq T(\alpha)$. We assume traces in every process $P$ to be prefix-closed; i.e., $\left\langle\right\rangle\in\mathit{beh}$ and for every non-empty trace $t^{\prime}=t\cdot\left\langle e\right\rangle\in\mathit{beh}$, $t\in\mathit{beh}$.

Parallel composition.

A pair of processes $P$ and $Q$ synchronize with each other by performing events $e_{1}$ and $e_{2}$, respectively, if these two events share at least one label. In their parallel composition, denoted $P\parallel Q$, this synchronization is represented by a new event $e^{\prime}$ that is constructed as the union of $e_{1}$ and $e_{2}$ (i.e., $e^{\prime}=e_{1}\cup e_{2}$).

Formally, let $P=(\alpha_{P},\mathit{evts}_{P},\mathit{beh}_{P})$ and $Q=(\alpha_{Q},\mathit{evts}_{Q},\mathit{beh}_{Q})$ be a pair of proceses. Their parallel composition is defined as follows:

[TABLE]

where $\alpha_{P\parallel Q}=\alpha_{P}\cup\alpha_{Q}$, and $cond(e)$ is defined as

[TABLE]

The definition of $\mathit{beh}_{P\parallel Q}$ states that if we take a trace $t$ in the composite process and ignore labels that appear only in $Q$, then the resulting trace must be a valid trace of $P$ (and symmetrically for $Q$). The condition (Cond. 1) is imposed on every event appearing in $traces_{P\parallel Q}$ to ensure that an event performed together by $P$ and $Q$ contains at least one common label shared by both processes.

This type of parallel composition can be seen as a generalization of the parallel composition of CSP [26], from single labels to sets of labels. That is, the CSP parallel composition is the special case of the composition of Def. 1 where every event is a singleton (i.e., it contains exactly one label). Note that if event $e$ contains exactly one label $a$, then $a$ must belong to the alphabet of $P$ or that of $Q$, which means $cond(e)$ always evaluates to true. The resulting expression in that case

[TABLE]

is equivalent to the definition of parallel composition in CSP [26, Sec. 2.3.3].

Mapping composition.

A mapping $m$ over set of labels $L$ is a partial function $m:L\fun L$. Informally, $m(a)=b$ stipulates that every event that contains $a$ as a label is to be assigned $b$ as an additional label. We sometimes use the notations $a\mapsto_{m}b$ or $(a,b)\in m$ as alternatives to $m(a)=b$. When we write $m(a)=b$ we mean that $m(a)$ is defined and is equal to $b$. The empty mapping, denoted $m=\emptyset$, is the partial function $m:L\to L$ which is undefined for all $a\in L$.

Mapping composition allows a pair of processes to interact with each other over distinct labels. Formally, consider two processes $P=(\alpha_{P},\mathit{evts}_{P},\mathit{beh}_{P})$ and $Q=(\alpha_{Q},\mathit{evts}_{Q},\mathit{beh}_{Q})$, and let $L=\alpha_{P}\cup\alpha_{Q}$. Given mapping $m:L\fun L$, the mapping composition $P\|_{m}Q$ is defined as follows:

[TABLE]

where $\alpha_{P\|_{m}Q}=\alpha_{P}\cup\alpha_{Q}$, and $cond^{\prime}(e)$ and $condmap(e,m)$ are defined as:

[TABLE]

The definition of $events$ in Def. 2 is similar to Def. 1 above, but not identical: the additional disjunct in $cond^{\prime}(e)$ allows $P$ and $Q$ to synchronize even when they do not share any label, if at least one pair of their labels are mapped to each other in $m$. The predicate $condmap$ ensures that if an event $e$ contains a label $a$, and $m$ maps $a$ to another label $b$, then $e$ also contains $b$.

Note that Def. 2 is different from the definition of mapping composition in [33], and corrects a flaw in the latter. In particular, the definition in [33] omits condition $cond^{\prime}$, which permits the undesirable case in which events $e_{1}$ and $e_{2}$ from $P$ and $Q$ are synchronized into union $e=e_{1}\cup e_{2}$ even when the two events do not share any label.

Mapping composition is a generalization of parallel composition: The latter is a special case of mapping composition where the given mapping is empty:

Lemma 3.1**.**

Given a pair of processes $P$ and $Q$, if $m=\emptyset$ then $P\|_{m}Q=P\parallel Q$.

Proof.

If $m=\emptyset$, the second disjunct of $cond^{\prime}(e)$ in Def. 2 is false, and thus $cond^{\prime}(e)$ $=$ $cond(e)$. In addition, $condmap(e,m)$ evaluates to true, and Def. 2 becomes equivalent to Def. 1. ∎

Example. Consider two processes, $P$ and $Q$, such that $\alpha_{P}=\{a,b\}$ and $\alpha_{Q}=\{x,y\}$. Let $t_{1}\in\mathit{beh}_{P}$ and $t_{2}\in\mathit{beh}_{Q}$ be two traces, where $t_{1}=\left\langle\{b\},\{a\}\right\rangle$ and $t_{2}=\left\langle\{x\},\{y\},\{x\}\right\rangle$. Suppose that we wish to compose $P$ and $Q$ by mapping $a$ to $x$; i.e., $m(a)=x$, and $m$ is undefined for all other labels. This mapping stipulates that every event containing $a$ as a label is to be assigned $x$ as an additional label in the resulting composite process. Then, the following is not a valid trace of the composition (even though its projections to $\alpha_{P}$ and $\alpha_{Q}$ give traces that are valid elements of $P$ and $Q$ respectively):

$\displaystyle\left\langle\{b\},\{a\},\{x\},\{y\},\{x\}\right\rangle\notin\mathit{beh}_{P\|_{m}Q}$

The reason why the above trace is not in $P\|_{m}Q$ is that its second event, $\{a\}$, is missing $x$, even though it contains $a$ and $a$ is mapped to $x$. The next trace is valid:

$\displaystyle\left\langle\{b\},\{a,x\},\{y\},\{x\}\right\rangle\in\mathit{beh}_{P\|_{m}Q}$

Note that the mapping is not symmetric, which means that although it is necessary for $a$ to synchronize with $x$, it is not necessary for $x$ to synchronize with $a$. Thus, the fourth event in the above trace contains $x$ without $a$. The following is also a valid trace of the composition:

$\displaystyle\left\langle\{b\},\{x\},\{y\},\{a,x\}\right\rangle\in\mathit{beh}_{P\|_{m}Q}$

Here, $\{a\}$ from $t_{1}$ is synchronized with the second $\{x\}$ of $t_{2}$, while the first $\{x\}$ of $t_{2}$ is allowed to take place by itself in the composition.

In a mapping composition $P\|_{m}Q$, $P$ is typically a high-level or abstract model of an application design, while $Q$ is a model of a low-level platform on which $P$ is to be implemented ($P$ and $Q$ may themselves consist of several processes). In most cases, the two processes describe system artifacts that are built independently from each other, and thus do not have any common labels. The mapping $m$ captures decisions on how events from $P$ are to be realized in terms of their counterparts in $Q$. Consequently, $P\|_{m}Q$ describes the result of implementing $P$ on $Q$ using these decisions.

Example. Let $P=\textsf{\small{Alice}}\parallel\textsf{\small{Bob}}\parallel\textsf{\small{Eve}}$ and $Q=\textsf{\small{Sender}}\parallel\textsf{\small{Receiver}}$ be the abstract and public channel communication models from Figure 1, respectively. In this model, labels are of the form ${\textsf{\small{writeBob}}(m)}$ or $\textsf{\small{encWrite}}(m,k)$, where $m\in\textsf{\small{Msg}}$ and $k\in\textsf{\small{Key}}$ are parameters. The domains of such parameters can be potentially infinite, resulting in infinite sets of labels. In this case, for the sake of simplicity, we restrict the domains Msg and Key to be finite:

$\displaystyle\textsf{\small{Msg}}=\{{\textsf{\small{public}}},{\textsf{\small{secret}}}\}\qquad\textsf{\small{Key}}=\{{\textsf{\small{none}}},\textsf{\small{k}}_{\textsf{\small{{X}}}},\textsf{\small{k}}_{\textsf{\small{{Y}}}}\}$

This, in turn, results in finite sets of labels (and thus, also a finite number of possible mappings):

$\displaystyle L_{P}=\{{\textsf{\small{writeBob}}({\textsf{\small{public}}})},{\textsf{\small{writeBob}}({\textsf{\small{secret}}})},{\textsf{\small{writeEve}}({\textsf{\small{public}}})},{\textsf{\small{writeEve}}({\textsf{\small{secret}}})}\}$

$\displaystyle L_{Q}=\{\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}}),\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{Y}}}}),$

$\displaystyle\quad\quad\quad\ \textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}}),\textsf{\small{encWrite}}({\textsf{\small{public}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\textsf{\small{encWrite}}({\textsf{\small{public}}},\textsf{\small{k}}_{\textsf{\small{{Y}}}})\}$

Suppose that we decide on a naive implementation scheme where the abstract messages writeBob and writeEve are transmitted over the public channel unencrypted. This decision can be represented as a mapping $m_{1}$ where each abstract label is mapped to encWrite with key $k={\textsf{\small{none}}}$:

$\displaystyle m_{1}=$ $\displaystyle\{({\textsf{\small{writeBob}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})),({\textsf{\small{writeEve}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})),$

$\displaystyle({\textsf{\small{writeBob}}({\textsf{\small{public}}})},\textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}})),({\textsf{\small{writeEve}}({\textsf{\small{public}}})},\textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}}))\}$

Then, the process $P\|_{m_{1}}Q$ contains traces that include the following event:

$\displaystyle e=\{{\textsf{\small{writeBob}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})\}$

The labels of such a multi-label event correspond to its representations at multiple abstraction layers; in this case, $e$ can be considered as both a writeBob and an encWrite event.

On the other hand, the singleton event $e^{\prime}=\{{\textsf{\small{writeBob}}({\textsf{\small{secret}}})}\}$ cannot appear in any trace of $P\|_{m_{1}}Q$, since the mapping $m_{1}$ requires that each event containing ${\textsf{\small{writeBob}}({\textsf{\small{secret}}})}$ also contain $\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})$.

3.2 Properties of Composition Operators

In this section, we state and prove various properties of the parallel and mapping composition operators, extending prior work [33] with new theoretical results.

Prefix closure.

Both the parallel and mapping composition operators preserve the prefix-closure property of processes.

Lemma 3.2**.**

Given a pair of processes $P$ and $Q$, $traces_{P\|_{m}Q}$ is prefix-closed.

Proof.

By definition, $\left\langle\right\rangle\in\mathit{beh}_{P\|_{m}Q}$.

Let $t^{\prime}=t\cdot\left\langle e\right\rangle\in\mathit{beh}_{P\|_{m}Q}$. By the definition of $traces$, $(t^{\prime}\project\alpha_{P})=(t\cdot\left\langle e\right\rangle\project\alpha_{P})\in P$. Since $P$ is prefix-closed, it must be the case that $(t\project\alpha_{P})\in traces_{P}$ (similarly, $(t\project\alpha_{Q})\in\mathit{beh}_{Q}$). Thus, it follows that $t\in\mathit{beh}_{P\|_{m}Q}$. ∎

Lemma 3.3**.**

Given a pair of processes $P$ and $Q$, $traces_{P\parallel Q}$ is prefix-closed.

Proof.

It follows as a special case of Lemma 3.2 with $m=\emptyset$. ∎

Commutativity.

The proposed mapping composition operator is commutative: i.e., $P\|_{m}Q=Q\|_{m}P$. This property can be inferred from the fact that Def. 2 is symmetric with respect to $P$ and $Q$. It follows that by being a special case of mapping composition, our parallel composition operator is also commutative.

Associativity.

Our parallel composition is not associative in general. For example, consider three processes, $P$, $Q$, and $R$, with the following traces:

[TABLE]

where $\alpha_{P}=\{b,c\}$, $\alpha_{Q}=\{b\}$, and $\alpha(R)=\{c\}$. If $P$ with $Q$ are first composed, and then consequently with $R$, we obtain:

[TABLE]

However, if $Q$ and $R$ are composed first, then $\{b\}$ and $\{c\}$ are interleaved as two distinct events. Consequently, when $(Q\parallel R)$ is further composed with $P$, $\{b,c\}$ cannot take place in the final composition:

[TABLE]

The mapping composition $\|_{m}$ is also not associative in general, since $\parallel$ itself is not associative; in fact, $\|_{m}$ is not associative in general even when the mapping $m$ is not empty. For example, consider three processes, $P$, $Q$, and $R$, with the traces:

[TABLE]

where $\alpha_{P}=\{a\}$, $\alpha_{Q}=\{b\}$, and $\alpha(R)=\{c\}$. Let $m_{1}=\{(a,b)\}$ and $m_{2}=\{(a,c)\}$. Then, $(P\|_{m_{1}}Q)\|_{m_{2}}R\neq P\|_{m_{1}}(Q\|_{m_{2}}R).$ On the right hand side, when $Q$ and $R$ are composed under $m_{2}$, $\{b\}$ and $\{c\}$ are interleaved as separate events in the resulting process, since neither $b$ or $c$ appears in the domain of $m_{2}$:

[TABLE]

When we further compose this process with $P$ under $m_{1}$, the resulting process will contain traces where $a$ is merged with $b$; e.g.,

[TABLE]

On the other hand, if $P$ is first composed with $Q$ under $m_{1}$, and then subsequently with $R$ under $m_{2}$, the resulting process has a trace where an event contains all of $a$, $b$, and $c$:

[TABLE]

Despite the above negative general results, we can show that our composition operators are associative under certain conditions on the alphabets of involved processes and mappings.

Theorem 3.4**.**

Given processes $P$, $Q$, and $R$, let $X=(P\|_{m_{1}}Q)\|_{m_{2}}R$ and $Y=P\|_{m_{3}}(Q\|_{m_{4}}R)$. If $\mathit{evts}(X)=\mathit{evts}(Y)$, then $X=Y$.

Proof.

Found in Appendix A.1. ∎

4 Verification Problems

Our framework allows to formulate several interesting problems related to mappings. One such problem is mapping verification: given $P,Q,m$, and a property $\phi$, check whether $P\|_{m}Q$ satisfies $\phi$. This verification problem has already been studied in [33], although not formulated explicitly as such, and not formalized completely. Here, we propose a complete formalization of the mapping verification problem, and in particular clarify the relation between the specification of properties at the high-level design and at the low-level implementation. At the same time, we prepare the ground for the formulation of the synthesis problems that follow in Section 5.

4.1 Specification

Before defining the mapping verification problem, let us explain how our framework allows the specification of properties at different levels of abstraction seamlessly. Recall that the goal of our methodology is to allow the system designer to express a desired property on a high-level design $P$ and preserve the same property as the design is implemented on a low-level platform ($P\|_{m}Q$). Therefore, ideally, we would like to be able to do the following: (1) Model the high-level design as process $P$. (2) Express the desired properties as a specification $\phi$. (3) Check that the design satisfies its specification, i.e., check that $P\models\phi$. (4) Model the execution platform as process $Q$. (5) Express the implementation decisions as a mapping $m$. (6) Check that the original implementation is not violated in the implemented system, i.e., check that $(P\|_{m}Q)\models\phi$.

Unfortunately, we cannot immediately follow the steps above and “reuse” the original specification $\phi$ in the mapping verification problem. The reason is that the high-level process $P$ contains traces which are of a different type from the traces of the implementation model $P\|_{m}Q$. Indeed, $P$ is a subset of $T(2^{\alpha(P)})$, whereas $P\|_{m}Q$ is a subset of $T(2^{\alpha(P)\cup\alpha(Q)})$. Also, the specification $\phi$ should ideally be implementation independent, which means that $\phi$ should be of the same type as $P$, i.e., a set of traces in $T(2^{\alpha(P)})$. Therefore, $\phi$ is a-priori incomparable with $P\|_{m}Q$, and the problem of checking $(P\|_{m}Q)\models\phi$ becomes ill-defined.

We take the following approach to resolve this incompatibility. In this paper, we are interested in specifications that are expressible as a trace property [2] (i.e., a set of traces describing desirable system behaviors). An initial property specified over $P$ would contain traces that are expressed only in terms of the alphabet of $P$; let us label this property $X$. Once $P$ is realized as part of $Q$ through mapping $m$, some subset of the traces of the resulting process ($P\|_{m}Q$) would capture behaviors that are consistent with $X$ and expressed over the alphabets of both $P$ and $Q$; let us refer to the largest such subset as $X^{\prime}$. In other words, $X^{\prime}$ is the property that captures the designer’s intent in the platform implementation $P\|_{m}Q$.

Our goal is to allow the designer to specify only an initial specification that yields $X$, and have $X^{\prime}$ derived automatically from the same specification when $P$ is mapped to $Q$. To achieve this, we treat specification $\phi$ as a syntactic object that is constructed in terms of some given set of labels $L_{\phi}$. To obtain its meaning as a property, $\phi$ is evaluated with respect to some set of labels $L$. The evaluation function, $sem$ is defined as follows:

[TABLE]

where $sat$ returns true if and only if trace $t$ satisfies the specification $\phi$. Note that $sem$ requires only that the input set $L$ contains at least those labels over which $\phi$ is expressed; in other word, $L$ may contain labels that are not mentioned by $\phi$. This allows us to construct properties over multiple levels of system abstraction from a single specification $\phi$:

[TABLE]

The meaning of $sat$ itself depends on the type of specification $\phi$. For instance, if $\phi$ is a first-order logic predicate with free variable $t$ that corresponds to trace $t$, then we can define the meaning of $sat$ simply as:

[TABLE]

Given the above notion of specification, we can now define what it means for a system, modeled as a process, to satisfy its specification:

[TABLE]

In other words, the traces allowed by $P$ must be a subset of the property that is constructed from $\phi$ and the alphabet of $P$.

Example. Recall the example from Figure 1, where the desired specification that Eve never learns the secret of Alice may be stated as the first-order logic formula

$\displaystyle\neg\exists e\in events(t):\textsf{\small{writeEve}}({\textsf{\small{secret}}})\in e$

where $t$ represents a trace over the set of all labels $L$. Let $\phi$ refer to this formula, $P$ the abstract model in Figure 1(a), and $Q$ the concrete model in Figure 1(b). Then, the following trace (of length 2), which describes Alice sending a secret to Bob, and then a public message to Eve, is a valid behavior according to the specification, since it does not result in Eve learning the secret:

$\displaystyle\left\langle\{\textsf{\small{writeBob(secret)}}\},\{\textsf{\small{writeEve(public)}}\}\right\rangle\in sem(\phi,\alpha(P))$

Similarly, the following trace, expressed over the labels that appear in $P$ and $Q$, is also a valid behavior as defined by $\phi$:

$\displaystyle\left\langle\{\textsf{\small{writeBob(secret)}},\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}})\},\{\textsf{\small{writeEve(public)}},\textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}})\}\right\rangle\in sem(\phi,\alpha(P\|_{m}Q))$

because executing this sequence of events does not lead to state SecretLearned.

4.2 Verification

In formal methods, a typical verification problem involves, given a process $P$ and a property $\phi$, checking whether $P$ satisfies $\phi$ (i.e., $P\models\phi$). In our framework, an additional verification problem is defined as follows:

Problem 1** (Mapping Verification).**

Given processes $P$ and $Q$, mapping $m$, and property $\phi$, check whether $(P\|_{m}Q)\models\phi$.

We say a mapping $m$ is valid (w.r.t. $P$, $Q$ and $\phi$) if and only if $(P\|_{m}Q)\models\phi$. When solving the mapping verification problem, we may rely on the assumption that $P$ alone satisfies the specification, i.e., that $P\models\phi$ holds (which could be checked beforehand). Note that this problem is conceptually an $\exists$-problem, as it can be stated as finding a witness trace $t$ to formula $\exists t:t\in(P\|_{m}Q)\land t\not\in\phi$.

Such problems can be answered in a non-exhaustive manner using satisfiability solvers. By “non-exhaustive” we mean that when the state-space is infinite, the solver typically gives an incomplete answer, by exploring only a finite subset of the state-space.

Another type of analysis problem, also introduced in [33], can be stated on mappings as follows:

Problem 2** (Insecure Mapping Search).**

Given processes $P$ and $Q$, and property $\phi$, find a mapping $m$ such that ($P\|_{m}Q)\not\models\phi$.

Such a mapping $m$, if it exists, describes decisions that may introduce undesirable behavior into the resulting implementation, undermining a property $\phi$ that has been previously established by $P$. Note that this problem is a search rather than a synthesis problem, since it can be formulated as an $\exists$-problem: $\exists m,\exists t:t\in(P\|_{m}Q)\land t\not\in\phi$.

Example. Recall the mapping $m_{1}$ from Section 3.1, where abstract messages are transmitted as unencrypted public messages. Let $\textsf{\small{Alice}}^{\prime}$ and $\textsf{\small{Eve}}^{\prime}$ be processes that represent the implementation of Alice as Sender using $m_{1}$ (i.e., $\textsf{\small{Alice}}\|_{m_{1}}\textsf{\small{Sender}}$), and Eve as Receiver, respectively. The following $t_{1}$ and $t_{2}$ are valid traces of these two processes:

$\displaystyle t_{1}=\left\langle\{{\textsf{\small{writeBob}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})\}\right\rangle\in\textsf{\small{Alice}}^{\prime}$

$\displaystyle t_{2}=\left\langle\{{\textsf{\small{writeEve}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})\}\right\rangle\in\textsf{\small{Eve}}^{\prime}$

When composed in parallel, $\textsf{\small{Alice}}^{\prime}$ and $\textsf{\small{Eve}}^{\prime}$ may interact through the above two events, since they share the common label encWrite $({\textsf{\small{secret}}},{\textsf{\small{none}}})$. According to the definition (1) from Section 3.1, the following is a valid trace of their parallel composition:

$\displaystyle\left\langle\{{\textsf{\small{writeBob}}({\textsf{\small{secret}}})},{\textsf{\small{writeEve}}({\textsf{\small{secret}}})},\textsf{\small{encWrite}}({\textsf{\small{secret}}},{\textsf{\small{none}}})\}\right\rangle\in(\textsf{\small{Alice}}^{\prime}\|\textsf{\small{Eve}}^{\prime})$

Note that in Figure 1(a), this event results in the transition of Eve into state SecretLearned, leading to a violation of the desired property. This can be seen as an example of abstraction violation: As a result of design decisions in $m_{1}$, writeBob and writeEve now share the same underlying representation (encWrite), and $\textsf{\small{Eve}}^{\prime}$ is now able to engage in an event that was not previously available to it in the original abstract model.

5 Synthesis Problems

In this paper, we propose the novel problem of synthesizing a mapping that preserves a desired property $\phi$ between $P$ and $Q$.

Problem 3** (Mapping Synthesis).**

Given processes $P$ and $Q$, and property $\phi$, find, if it exists, a mapping $m$ such that $(P\|_{m}Q)\models\phi$.

Note that this problem can be stated as a $\exists\forall$ problem; that is, finding a witness $m$ to the formula $\exists m:\forall t:t\in(P\|_{m}Q)\implies t\in\phi$.

Instead of synthesizing $m$ from scratch, the developer may often wish to express her partial system knowledge as a given constraint, and ask the synthesis tool to generate a mapping that adheres to this constraint. For instance, given labels $a,b,c\in L$, one may express a constraint that $a$ must be mapped to either $b$ or $c$ as part of every valid mapping; this gives rise to two possible candidate mappings, $m_{1}$ and $m_{2}$, where $m_{1}(a)=b$ and $m_{2}(a)=c$. Formally, let $M$ be the set of all possible mappings between labels $L$. A mapping constraint $C\subseteq M$ is a set of mappings that are considered legal candidates for a final, synthesized valid mapping. Then, the problem of synthesizing a mapping given a constraint can be formulated as follows:

Problem 4** (Generalized Mapping Synthesis).**

Given $P$ and $Q$, property $\phi$, and mapping constraint $C$, find, if it exists, a mapping $m$ such that $m\in C$ and $(P\|_{m}Q)\models\phi$.

Note that Problem 3 is a special case of Problem 4 where $C=M$.

Example. Consider a pair of processes, $P$ and $Q$, such that $\alpha(P)=\{a,b\}$ and $\alpha(Q)=\{x,y,z\}$. Suppose that the developer wishes to map $a$ to either $x$ or $y$, and $b$ to $z$; this can be specified as the following constraint:

$\displaystyle C=\{m_{1},m_{2}\}\quad m_{1}=\{(a,x),(b,z)\}\quad m_{2}=\{(a,y),(b,z)\}$

Suppose instead that the developer’s intent is to map $a$ to any one of the labels in $Q$, but not map $b$ to anything; this can be specified as

$\displaystyle C=\{m_{1},m_{2},m_{3}\}\quad m_{1}=\{(a,x)\}\quad m_{2}=\{(a,y)\}\quad m_{3}=\{(a,z)\}$

The synthesis problem can be further generalized to one that involves synthesizing a constraint that contains a set of valid mappings:

Problem 5** (Mapping Constraint Synthesis).**

Given $P$ and $Q$, property $\phi$, and mapping constraint $C$, generate a non-empty constraint $C^{\prime}$ such that $C^{\prime}\subseteq C$, and for every $m\in C^{\prime}$, $(P\|_{m}Q)\models\phi$.

If it exists, $C^{\prime}$ yields a set of valid mappings that adhere to the given constraint $C$ (i.e., $C^{\prime}$ is a stronger constraint than $C$). We call such constraint $C^{\prime}$ valid with respect to $P$, $Q$, $\phi$ and $C$. A procedure for solving Problem 5 can in turn be used to solve Problem 4: Having generated constraint $C^{\prime}$, we pick some mapping $m$ such that $m\in C^{\prime}$.

In practice, it is desirable for a synthesized constraint to be as large as possible while still being valid, as it provides more implementation choices (i.e., possible mappings). The problem of synthesizing a maximal mapping constraint is defined as:

Problem 6** (Maximal Constraint Synthesis).**

Given processes $P$ and $Q$, property $\phi$, and given constraint $C$, generate a constraint $C^{\prime}$ such (1) $C^{\prime}$ is valid with respect to $P$, $Q$, $\phi$, and $C$, and (2) there exists no other constraint $C^{\prime\prime}$ such that $C^{\prime\prime}$ is valid and $C^{\prime}\subseteq C^{\prime\prime}$.

Note that $C^{\prime}$, if found, is a local optimum. In general, there may be multiple local optimal constraints for given $P$, $Q$, $\phi$, and $C$.

Example. In our running example, suppose that there are two Receiver processes with the identical behavior ($\textsf{\small{Receiver}}_{\textsf{\small{X}}}$ and $\textsf{\small{Receiver}}_{\textsf{\small{Y}}}$), except that they are assigned unique decryption keys: ${\textsf{\small{knows}}}(\textsf{\small{Receiver}}_{\textsf{\small{X}}})$ $=$ $\{\textsf{\small{k}}_{\textsf{\small{{X}}}}\}$ and ${\textsf{\small{knows}}}(\textsf{\small{Receiver}}_{\textsf{\small{Y}}})$ $=$ $\{\textsf{\small{k}}_{\textsf{\small{{Y}}}}\}$. Then, the following $m_{2}$ is a valid mapping that preserves the desired specification that Eve never learns the secret:

$\displaystyle{\textsf{\small{writeBob}}({\textsf{\small{secret}}})}\mapsto_{m_{2}}\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\ {\textsf{\small{writeBob}}({\textsf{\small{public}}})}\mapsto_{m_{2}}\textsf{\small{encWrite}}({\textsf{\small{public}}},\textsf{\small{k}}_{\textsf{\small{{X}}}})$

$\displaystyle{\textsf{\small{writeEve}}({\textsf{\small{secret}}})}\mapsto_{m_{2}}\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\ {\textsf{\small{writeEve}}({\textsf{\small{public}}})}\mapsto_{m_{2}}\textsf{\small{encWrite}}({\textsf{\small{public}}},\textsf{\small{k}}_{\textsf{\small{{Y}}}})$

That is, if the secret message are always encrypted with the key assigned to Bob, Eve will never be able to read it. The following $m_{3}$ is also a a valid mapping:

$\displaystyle{\textsf{\small{writeBob}}({\textsf{\small{secret}}})}\mapsto_{m_{3}}\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\ {\textsf{\small{writeBob}}({\textsf{\small{public}}})}\mapsto_{m_{3}}\textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}})$

$\displaystyle{\textsf{\small{writeEve}}({\textsf{\small{secret}}})}\mapsto_{m_{3}}\textsf{\small{encWrite}}({\textsf{\small{secret}}},\textsf{\small{k}}_{\textsf{\small{{X}}}}),\ {\textsf{\small{writeEve}}({\textsf{\small{public}}})}\mapsto_{m_{3}}\textsf{\small{encWrite}}({\textsf{\small{public}}},{\textsf{\small{none}}})$

since Eve being able to read public messages does not violate the property. Thus, the developer may choose either $m_{2}$ or $m_{3}$ to implement the abstract channel and ensure that secret remains protected from Eve. In other words, $C_{1}=\{m_{2},m_{3}\}$ is a valid (but not necessarily maximal) mapping constraint with respect to the desired property. Furthermore, $C_{1}$ is arguably more desirable than another constraint $C_{2}=\{m_{2}\}$, since the former gives the developer more implementation choices than the latter does.

6 Synthesis Technique

Mapping representation.

Assuming that the set of event labels $L$ is finite, one possible way to represent a mapping is by explicitly listing all of the entries in the function. An alternative representation is one where mappings are represented symbolically as logical expressions over variables that correspond to labels being mapped. The symbolic representation has the following advantages: (1) it provides a succinct representation of implementation decisions to the developer (which is especially important as the size of the mapping grows large) and (2) it allows the user to specify partial decisions (i.e., given constraint $C$) in a declarative manner.

In particular, we use a grammar-based approach, where the space of candidate mapping constraints is restricted to expressions that can be constructed using a syntactic grammar [3]. Our grammar is described as follows:

[TABLE]

where $Var$ is a set of variables that represent parameters inside a label, and $Const$ is the set of constant values. Intuitively, this grammar captures implementation decisions that involve assignments of parameters in an abstract label to their counterparts in a concrete label (represented by the equality operator “$=$”). A logical implication is used to construct a conditional assignment of a parameter. For example, expression $\mathcal{X}_{\textsf{writeBob}}(a,b)$ $\equiv$ $a.m=b.m$ $\land$ $(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})$ states that if the message being transmitted is a secret, key $\textsf{\small{k}}_{\textsf{\small{{X}}}}$ must be used ($a$ and $b$ are variables representing writeBob and encWrite labels, respectively).

In general, given an expression, the constraint that it represents is computed as:

[TABLE]

That is, a mapping $m$ is allowed by $C$ if and only if for each label $a$, (1) if there is at least another label $b$ for which $\mathcal{X}(a,b)$ evaluates to true, then $m$ maps $a$ to one of such labels, and (2) otherwise, $m$ is not defined over $a$.

Example. In our running example, the signatures associated with event labels are as follows:

$\displaystyle\textsf{\small{writeBob}}(m:\textsf{\small{Msg}})\ \textsf{\small{writeEve}}(m:\textsf{\small{Msg}})\ \textsf{\small{encWrite}}(m:\textsf{\small{Msg}},k:\textsf{\small{Key}})$

Separate constraint expressions are used to capture the mapping between writeBob and encWrite, and writeEve and encWrite; we will call these expressions $\mathcal{X}_{\textsf{\small{writeBob}}}$ and $\mathcal{X}_{\textsf{\small{writeEve}}}$, respectively. One possible mapping constraint that preserves the secrecy property may be expressed as follows:

\displaystyle E_{\textsf{\small{writeBob}}}(a,b)\equiv\ $\displaystyle a.m=b.m\land(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})$

\displaystyle E_{\textsf{\small{writeEve}}}(a,b)\equiv\ $\displaystyle a.m=b.m\land(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})$

Informally, these expressions stipulate that (1) the messages associated with the high-level and low-level events are identical, and (2) if the message being transmitted is a secret, the key associated with $\textsf{\small{Bob}}^{\prime}$ must be used. Note that this constraint does not specify which keys should used to encode public messages, since this decision is not relevant to the secrecy property. This under-specification is desirable, since it gives more implementation freedom to the developer while preserving the desired property at the same time.

Algorithmic considerations.

To ensure that the algorithm terminates, the set of expressions that may be constructed using the given grammar is restricted to a finite set, by bounding the domains of data types (e.g., Msg and Key in our example) and the size of expressions. We also assume the existence of a verifier that is capable of checking whether a candidate mapping satisfies a given property $\phi$. The verifier is used to implement function $verify(C,P,Q,\phi)$, which returns $OK$ if and only if every mapping allowed by constraint $C$ satisfies $\phi$.

Naive algorithm.

Once we limit the number of candidate expressions to be finite, we can use a brute-force algorithm to enumerate and check those candidates one by one. Unfortunately, this naive algorithm is likely to suffer from scalability issues, as our experimental results indeed indicate (see Section 7, Figure 5).

Generalization algorithm.

We present an improved algorithm that takes a generalization-based approach to dynamically identify and prune undesirable parts of the search space. A key insight is that only a few implementation decisions—captured by some minimal subset of the entries in a mapping—may be sufficient to imply that the resulting implementation will be invalid. Thus, given some invalid mapping, the algorithm attempts to identify this minimal subset and construct a larger constraint $C_{bad}$ that is guaranteed to contain only invalid mappings.

The outline of the algorithm is shown in Fig. 2. The function $synthesize$ takes four inputs: a pair of processes, $P$ and $Q$, a desired specification $\phi$, and a user-specified constraint $C_{0}$. It also stores a set of constraints, $X$, which keeps track of “bad” regions of the search space that do not contain any valid mappings.

In each iteration, the algorithm selects some mapping $m$ from $C_{0}$ (line 3) and checks whether it belongs to one of the constraints in $X$ (meaning, the mapping is guaranteed to result in an invalid implementation). If so, it is simply discarded (lines 4-5).

Otherwise, the verifier is used to check whether $m$ is valid with respect to $\phi$ (line 7). If so, then $generalize$ is invoked to produce a maximal mapping constraint $C_{maximal}$, which represents the largest set that contains $\{m\}$ and is valid with respect to $\phi$ (line 9). If, on the other hand, $m$ is invalid (i.e., it fails to preserve $\phi$), then $generalize$ is invoked to compute the largest superset $C_{bad}$ of $\{m\}$ that contains only invalid mappings (i.e., those that satisfy $\neg\phi$). The set $C_{bad}$ is then added to $X$ and used to prune out subsequent, invalid candidates (line 13).

Constraint generalization.

The function $generalize(C,P,Q,\phi,C_{0})$ computes the largest set that contains $C$ and only permits mappings that satisfy $\phi$. This function is used both to identify an undesirable region of the candidate space that should be avoided, and also to produce a maximal version of a valid mapping constraint.

The procedure works by incrementally growing $C$ into a larger set $C^{\prime}$ and stopping when $C^{\prime}$ contains at least one mapping that violates $\phi$. Suppose that constraint $C$ is represented by a symbolic expression $\mathcal{X}$, which itself is a conjunction of $n$ subexpressions $k_{1}\land k_{2}\land...\land k_{n}$, where each $k_{i}$ for $1\leq i\leq n$ represents a (possibly conditional) assignment of a variable or a constant to some label parameter. The function $decompose(C)$ takes the given constraint and returns the set of such subexpressions222We assume that a symbolic expression representing constraint $C$ is available to $decompose$.. The function $relax(C,k_{i})$ then computes a new constraint by removing $k$ from $C$; this new constraint, $C^{\prime}$, is a larger set of mappings that subsumes $C$.

The verifier is then used to check $C^{\prime}$ against $\phi$ (line 22). If $C^{\prime}$ is still valid with respect to $\phi$, it implies that the implementation decision encoded by $k$ is irrelevant to $\phi$, meaning we can safely remove $k$ from the final synthesized constraint $C$ (line 24). If not, $k$ is retained as part of $C$, and the algorithm moves onto the next subexpression $k$ as a candidate for removal (line 20).

Example. Back to our running example, one candidate constraint $C$ (line 3) is represented in part by the following expression (for mappings from writeEve to encWrite):

$\displaystyle\mathcal{X}(a,b)\equiv\ a.m=b.m\land(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})\land(b.m={\textsf{\small{public}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{Y}}}})$

The verifier returns $OK$ after checking $C$ against $P$, $Q$, and $\phi$ (line 7), meaning $C$ is a valid constraint. Next, the generalization procedure removes the subexpression $k_{1}=(b.m={\textsf{\small{public}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{Y}}}})$ from $C$, resulting in constraint $C^{\prime}$ that is represented as:

$\displaystyle\mathcal{X}(a,b)\equiv\ a.m=b.m\land$ $\displaystyle(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})$

When checked by the verifier (line 22), $C^{\prime}$ is still considered valid, meaning that the decision encoded by $k_{1}$ is irrelevant to the property; thus, $k_{1}$ can be safely removed.

However, removing $k_{2}=(b.m={\textsf{\small{secret}}}\implies b.k=\textsf{\small{k}}_{\textsf{\small{{X}}}})$ results in a violation of the property. Thus, $k_{2}$ is kept as part of the final maximal constraint expression.

7 Implementation and Case Study

This section describes an implementation of our synthesis technique, and a case study on security protocols. The goal of the study is to answer (1) whether our technique can be used to synthesize valid implementation mappings for realistic systems, and (2) how effective our generalization-based algorithm is over the naive approach.

7.1 Implementation

We have built a prototype tool that is capable of performing both the naive and generalization algorithms described in Section 6. Our tool is currently plugged in with two different verifiers: Spin [27], an explicit-state model checker, and the Alloy Analyzer [31], a modeling and analysis tool based on a first-order relational logic. Both tools have their strengths and weaknesses [46]. Spin provides stronger guarantees in that it is capable of fully exploring the state space, whereas Alloy performs a kind of bounded model checking (where the maximum length of traces explored is restricted to some fixed bound). On the other hand, in our experience so far, Alloy tends to find counterexamples more quickly (if they exist within the given bound), in part thanks to its constraint solving backend.

We began with an implementation that employed Spin as a verifier. Through our experiments, we discovered that as the size of the relaxed constraint $C^{\prime}$ increased during the iterative generalization procedure (line 21 in Algorithm 2), the verification task by Spin became more demanding, eventually becoming a major bottleneck in the synthesis algorithm. We then employed the Alloy Analyzer as the verifier, and found that it did not suffer from the same issue. We believe that this is partly due to the constraint-based nature of Alloy: The relaxation step involves simply removing a constraint from the Alloy model, and does not adversely affect the performance of the constraint solver (in some cases, it leads to improvement).

7.2 OAuth Protocols

As a major case study, we took on the problem of synthesizing valid mappings for OAuth, a popular family of protocols used to carry out a process called third-party authorization [30]. The purpose of OAuth is to allow an application (called a client in the OAuth terminology) to access a resource from another application (an authorization server) without needing the credentials of the resource owner (an user). For example, a gaming application may initiate an OAuth process to obtain a list of friends from a particular user’s Facebook account, provided that the user has authorized Facebook to release this resource to the client.

In particular, we chose to study two versions of OAuth—OAuth 1.0 and 2.0. Although OAuth 2.0 is intended to be a replacement for OAuth 1.0, there has been much contention within the developer community about whether it actually improves over its predecessor in terms of security. For this reason, certain major websites (such as Twitter and Flickr) still rely on OAuth 1.0, while others have adopted 2.0. In fact, the original creator of OAuth himself has recommended 1.0 as the more secure version [22]:

…OAuth 2.0 at the hand of a developer with deep understanding of web security will likely result is a secure implementation. However, at the hands of most developers…2.0 is likely to produce insecure implementations.

Since both protocols are designed to provide the same security guarantees (i.e., both share common properties), our goal was to apply our synthesis approach to systematically compare what developers would be required to do in order to construct secure web-based implementations of the two.

7.3 Experimental Setup

OAuth models.

We constructed Alloy models of OAuth 1.0 and 2.0 based on the official protocol specifications [29, 30]. Due to limited space, we give only a brief overview of the models. Each model consists of four processes: Client, AuthServer, and two users, Alice and Eve (latter with a malicious intent to access Alice’s resources).

A typical 2.0 workflow, shown in Figure 3(a), begins with a user (Alice or Eve) initiating a new protocol session with Client (initiate). The user is then asked to prove her own identity to AuthServer (by providing a user ID and a password) and officially authorize the client to access her resources (authorize). Given the user’s authorization, the server then allocates a unique code for the user, and then redirects her back to the client. The user forwards the code to the client (forward), which then can exchange the code for an access token to her resources (getToken).

Like in OAuth 2.0, a typical workflow in 1.0 (depicted in Figure 3(b)) begins with a user initiating a new session with Client (initiate). Instead of immediately directing the user to AuthServer, however, Client first obtains a request token from AuthServer and associates it with the current session (getReqToken). The user is then asked to present the same request token to AuthServer and authorize Client to access her resources (authorize). Once notified by the user that the authorization step has taken place (notify), Client exchanges the request token for an access token that can be used subsequently to access her resources (getAccessToken).

We specified two desirable properties of OAuth:

• •

Progress: Each protocol session can be completed with the client obtaining an access token for a user:

[TABLE]

where $t_{0}$ refers to the last event in trace $t$, and $t\leq t^{\prime}$ means $t$ is a prefix of $t^{\prime}$. In other words, if some user $u$ initiates an OAuth session, Client must eventually be able to obtain the access token for $u$.

• •

Integrity: When the client receives an access token, it must correspond to a user who initiated the protocol session in the past:

[TABLE]

In other words, if Client is able to obtain a token for some user $u$, then that same user must have initiated a session in the past.

To ensure the validity of the OAuth models before the synthesis step, we performed verification of the properties using Alloy; both properties were verified in several seconds.

HTTP platform model.

In this case study, our goal was to explore and synthesize web-based implementations of OAuth. For this purpose, we constructed a model depicting interaction between a generic HTTP server and web browser. To ensure the fidelity of our model, we studied, as references, similar efforts by other researchers in building reusable models of the web for security analysis [1, 8, 19] (none of these models, however, has been used for synthesis).

The model contains two types of processes, Server and Browser (which may be instantiated into multiple processes representing different servers and browsers). They interact with each other over HTTP requests, which share the following signature:

[TABLE]

The parameters of an HTTP request have their own internal structures, each consisting of its own parameters as follows:

[TABLE]

Our model describes generic, application-independent HTTP interactions. In particular, each Browser process is a machine that constructs, at each communication step with Server, an arbitrary HTTP request by non-deterministically selecting a value for each parameter of the request. The processes, however, follow a platform-specific logic; for instance, when given a response from Server that instructs a browser cookie to be stored at a particular URL, Browser will include this cookie along with every subsequent request directed at that URL. In addition, the model includes a process that depicts the behavior of a web attacker, who may operate her own malicious server and exploit weaknesses in a browser to manipulate the user into sending certain HTTP requests.

Mapping from OAuth to HTTP.

Building a web-based implementation of OAuth involves decisions about how abstract protocol operations are to be realized in terms of HTTP requests. As an input to the synthesizer, we specified an initial set of constraints that describe partial implementation decisions; the ones for OAuth 2.0 are shown in Figure 4. These decisions include a designation of fixed host and path names inside URLs for various OAuth operations (e.g., http:/client.com/initiate for the OAuth initiate event), and how certain parameters are transmitted as part of an HTTP request (ret_session as a return cookie in initiate). It is reasonable to treat these constraints as given, since they describe decisions that are common across typical web-based OAuth implementations.

Associativity.

Typically, in our methodology, the designer would start by composing the processes in an abstract protocol model (i.e., OAuth) to analyze the desired properties of the protocol before mapping it into the underlying platform; then, the process that represents the overall system, $Sys_{1}$, would be constructed as follows:

[TABLE]

Alternatively, the designer may first decide how each abstract process is implemented on the platform, and then compose the resulting concrete processes to construct the overall system, $Sys_{2}$, as follows:

[TABLE]

The former approach is useful in that it enables incremental analysis (i.e., reason about the properties of an abstract design before verifying the more detailed concrete implementation), while the latter facilitates incremental implementation (e.g., implement Client first before implementing AuthServer). In this case study, note that the processes and mappings satisfy the condition for the associativity theorem (Theorem A.4):

[TABLE]

Thus, both approaches to mapping yield an equivalent OAuth implementation model.

7.4 Results

Our synthesis tool was able to generate valid mapping constraints for OAuth 2.0 and 1.0. In particular, the constraints describe mitigations against attacks that exploit an interaction between the OAuth logic and a browser vulnerability, including session swapping [41], covert redirect [21] (both for OAuth 2.0), and session fixation [20] (for OAuth 1.0). We describe an example of how certain platform decisions may result in an attack, and how our synthesized mappings mitigate against this attack.

Insecure mapping.

Consider OAuth 2.0 from Figure 3(a). In order to implement the forward operation, for instance, the developer must determine how the parameters $code$ and $session$ of the abstract event label are encoded using their concrete counterparts in an HTTP request. A number of choices is available. In one possible implementation, the authorization code may be transmitted as a query parameter inside the URL, and the session as a browser cookie, as described by the following constraint expression, $\mathcal{X}_{1}$:

[TABLE]

where POST, client.com, forward, and cookie are predefined constants; and $l[i]$ refers to $i$-th element of list $l$.

This constraint, however, allows a vulnerable implementation where malicious user Eve performs the first two steps of the workflow in Figure 3(a) using her own credentials, and obtains a unique code ($\textsf{\small{code}}_{\mathsf{Eve}}$) from the authorization server. Instead of forwarding this to Client (as she is expected to), Eve keeps the code herself, and crafts her own web page that triggers the visiting browser to send the following HTTP request:

[TABLE]

Suppose that Alice is a naive browser user who may occasionally be enticed or tricked into visiting malicious web sites. When Alice visits the page set up by Eve, Alice’s browser automatically generates the above HTTP request, which, given the decisions in $\mathcal{X}_{1}$, corresponds to a valid forward event:

[TABLE]

Due to the standard browser logic, the cookie corresponding to $\textsf{\small{session}}_{\mathsf{Alice}}$ is included in every request to client.com. As a result, Client mistakenly accepts $\textsf{\small{code}}_{\mathsf{Eve}}$ as the one for Alice, even though it belongs to Eve, violating the integrity property of OAuth.

Synthesized, secure mapping.

Mapping expression $\mathcal{X}_{1}$ is incorrect as it allows insecure mappings. Our tool is able to automatically synthesize a secure mapping expression $\mathcal{X}_{2}$, described below. $\mathcal{X}_{2}$ fixes the major problem of $\mathcal{X}_{1}$, namely, that in a browser-based implementation, the client cannot trust an authorization code as having originated from a particular user (e.g., Alice), since the code may be intercepted or interjected by an attacker (Eve) while in transit through a browser. A possible solution is to explicitly identify the origin of the code by requiring an additional piece of tracking information to be provided in each forward request. The mapping expression $\mathcal{X}_{2}$ synthesized by our tool, given the input partial constraint in Figure 4, encodes one form of this solution:

[TABLE]

where $\textsf{\small{nonce}}_{o}$, $\textsf{\small{nonce}}_{1}\in\textsf{\small{Nonce}}$ are constants defined in the HTTP model333A nonce is a unique piece of string intended to be used once in communication.. In particular, $\mathcal{X}_{2}$ stipulates that every forward request must include an additional value (nonce) as an argument besides the code and the session, and that this nonce be unique for each session value. $\mathcal{X}_{2}$ ensures that the resulting implementation satisfies the desired properties of OAuth 2.

OAuth 1.0 vs 2.0.

Based on the comparison of the two protocol workflows in Figure 3, OAuth 2.0 appears simpler than its predecessor, which requires the client to perform an extra step to obtain a request token from the authorization server (Step 2 in Figure 3(b)).

Simplicity, however, sometimes can result in a loss of security. In OAuth 1.0, the client knows exactly the request token that it expects to receive in Step 4 (the same one as in Step 2). Thus, it needs not trust that the user will always deliver a correct request token in Step 4, and does not suffer from the above attack. OAuth 2.0, on the other hand, relies on the user to deliver a correct authorization code (Step 3 in Figure 3(a))—an assumption which does not necessarily hold in a browser-based implementation, as described above. In effect, the synthesized mapping $\mathcal{X}_{2}$ captures a way to harden OAuth 2.0 implementations against security risks of relying on this assumption.

Performance.

Figure 5 shows statistics from our experiments synthesizing valid mapping constraints for the two OAuth protocols444The experiments were performed on a Mac OS X 2.7 GHz machine with 8G RAM and MiniSat [18] as the underlying SAT solver employed by the Alloy Analyzer.. Overall, the synthesizer took approximately 17.6 and 24.0 minutes to synthesize the constraints for 1.0 and 2.0, respectively. This level of performance is acceptable for generic protocols such as OAuth: Once synthesized, the implementation guidelines captured by the constraints can be consulted by multiple developers to build their own OAuth implementations, amortizing the cost of the synthesis effort over time.

In both cases, the tool spent a considerable amount of time on the generalization step to learn the invalid regions of the search space. It can also be seen that the generalization is effective at identifying and discarding a large number of invalid candidates, and achieves a significant amount of speed up over the naive algorithm (4.48 and 1.88 times for OAuth 1.0 and 2.0, respectively).

Since OAuth 1.0 is a more complex protocol than 2.0, we expected the synthesis procedure to take more time on the former; indeed, the performance of the naive algorithm was consistent with this expectation (4732.63 vs 2717.41 seconds). However, we were surprised to find that the generalization-based algorithm was able to find a solution for OAuth 1.0 faster than it did for 2.0. In particular, the synthesizer spent a significantly larger proportion of its time on the generalization step ($1138.85/1441.60\approx 79\%$); one possible explanation is that the search space for OAuth 2.0 is more densely populated with incomparable invalid constraints than 1.0.

As an additional experiment, we ran the generalization-based algorithm to explore the search space exhaustively without terminating when a solution is found. The algorithm was able to skip 75375 out of 79200 candidates for OAuth 1.0 (roughly $95\%$), and 28140 out of 29400 candidates for OAuth 2.0 ($\approx 96\%$). This means that only 3825 and 1260 calls to the verifier were needed to exhaust the search space (for 1.0 and 2.0, respectively)—relatively small compared to the total number of candidates. Our generalization technique was particularly effective for the OAuth protocols, since a significant percentage of the candidate constraints would result in an implementation that violates the progress property (i.e., it prevents Alice or Eve from completing a protocol session in an expected order). Often, the decisions contributing to this violation could be localized to a small subset of entries in a mapping (for example, attempting to send a cookie to a mismatched URL, which is inconsistent with the behavior of the browser process). By identifying this subset, our algorithm was able to discover and eliminate a large number of invalid mappings.

Threats to validity.

One potential source of errors stems from the finitization of the system models. To finitize the set of labels $L$ and ensure that the synthesis procedure terminates, we bounded the size of datatype domains to 4 (i.e., 4 access tokens, cookies, etc.). While we believe that this bound is sufficient to explore possible interactions between protocol participants during an OAuth session, it is possible that we might have missed a potential security violation involving a larger number of data elements. To mitigate this risk, we plan to explore infinite-state verification methods (e.g., using SMT solvers [15, 17]) as part of future work.

8 Related Work

A large body of literature exists on refinement-based methods to system construction [25, 7]. These approaches involve building an implementation $Q$ that is a behavioral refinement of $P$; such $Q$, by construction, would satisfy the properties of $P$. In comparison, we start with an assumption that $Q$ is a given platform, and that the developer may not have the luxury of being able to modify or build $Q$ from scratch. Thus, instead of behavioral refinement (which may be too challenging to achieve), we aim to preserve some critical property $\phi$ when $P$ is implemented using $Q$.

The task of synthesizing a valid mapping can be seen as a type of the model merging problem [11]. This problem has been studied in various contexts, including architectural views [34], behavioral models [35, 9, 43], and database schemas [37]. Among these, our work is most closely related to merging of partial behavioral models [9, 43]. In these works, given a pair of models $M_{1}$ and $M_{2}$, the goal is to construct $M^{\prime}$ that is a behavioral refinement of both $M_{1}$ and $M_{2}$. The approach proposed in this paper differs in that (1) the mapping composition involves merging a pair of events with distinct alphabet labels into a single event that retains all of those labels, and (2) the composed process $(P\|_{m}Q)$ needs not be a behavioral refinement of $P$ or $Q$, as long as it satisfies property $\phi$.

Bhargavan and his colleagues presents a compiler that takes a high-level program written using session types [28] and automatically generates a low-level implementation [10]. This technique is closer to compilation than to synthesis in that it uses a fixed translation scheme from high-level to low-level operations in a specific language environment (.NET), without searching a space of possible translations.

Our approach is similar to a number of other synthesis frameworks [32, 39, 40, 4, 5, 6] in allowing the user to provide a partial specification of the artifact to be synthesized (in form of constraints or examples), having the underlying engine complete the remaining parts. This strategy is crucial for pruning the space of candidate solutions and keeping the synthesis problem tractable. Synthesizing a low-level implementation from a high-level specification has also been studied in the context of data structures [16, 23, 24].

9 Conclusions

In this paper, we have proposed a novel system design methodology centered around the notion of mappings. We have presented novel mapping synthesis problems and an algorithm for efficiently synthesizing valid mappings. In addition, we have validated our approach on realistic case studies involving the OAuth protocols.

As with many synthesis problems, scalability remains a challenge. One promising direction is to exploit the fact that our generalization-based algorithm (from Section 6) is easily parallelizable. We are currently devising an algorithm where multiple machines are used to explore different regions of the search space in parallel, only communicating to update and check the invalid constraint set $X$.

Our synthesis tool can be used in an interactive manner. If it fails to find a valid mapping constraint due to a given constraint $C$ that is too restrictive, the developer may relax $C$ and re-run the synthesis procedure. However, the tool currently does not provide an explanation for why it fails to synthesize a mapping; such an explanation could point to parts of $C$ that must be relaxed, or certain behavior of $Q$ that entirely precludes valid mappings. We are developing a root cause analysis technique that can be used to provide such explanations.

Another major next step is to bridge the gap between synthesized mappings (which describe implementation decisions at a modeling level) and code. For instance, a mapping may be used to directly generate a working implementation that preserves a desired property (e.g., a secure, reference OAuth implementation), or used as a code-level specification to check that a program adheres to the decisions described in the mapping. We are also exploring potential applications of our synthesis approach to other domains where a similar type of mapping arises, such as cyber-physical and embedded systems [12, 38, 42].

Acknowledgements

This work was partially supported by the NSF SaTC award “Bridging the Gap between Protocol Design and Implementation through Automated Mapping” (CNS-1801546), the NSF Breakthrough award “Compositional System Modeling” (CNS-132975), the NSF Expeditions in Computing project “ExCAPE: Expeditions in Computer Augmented Program Engineering” (CCF-1138860 and 1139138), and by the Academy of Finland.

Appendix A Proofs

A.1 Associativity of Mapping Composition

Let us first prove several lemmas that will enable us to prove a general theorem about associativity of mapping composition.

Lemma A.1**.**

Given trace $t\in T(L)$ and sets of labels $X,Y\subseteq L$ such that $X\subseteq Y$, $(t\project Y)\project X=t\project X$.

Proof.

Consider event $e\in events(t)$. Since $X\subseteq Y$, $(e\cap Y)\cap X=e\cap X$. Thus, by the definition of the projection operator, every event in $(t\project Y)\project X$ is also an event in $t\project X$. ∎

Lemma A.2**.**

Given processes $P$, $Q$, and $R$, let $X=(P\|_{m_{1}}Q)\|_{m_{2}}R$. Then, for any trace $t\in T(L)$, $t\in\mathit{beh}(X)$ if and only if all the following conditions hold:

$t\in(events(X))^{*}$** 2. 2.

$(t\project\alpha(P))\in\mathit{beh}(P)$** 3. 3.

$(t\project\alpha(Q))\in\mathit{beh}(Q)$** 4. 4.

$(t\project\alpha(R))\in\mathit{beh}(R)$**

Proof.

($\implies$ direction) Suppose that $t\in\mathit{beh}(X)$. By the definition of $traces((P\|_{m_{1}}Q)\|_{m_{2}}R)$, it follows that

[TABLE]

satisfying Conditions (1) and (4).

Let $t^{\prime}=t\project\alpha(P\|_{m_{1}}Q)=t\project\alpha(P\cup Q)$. By the definition of $traces(P\|_{m_{1}}Q)$,

[TABLE]

Based on Lemma A.1, we can further conclude the following:

[TABLE]

from which it follows that Conditions (2) and (3) hold.

($\Leftarrow$ direction) Suppose that the above four conditions hold. Since $t\in(events(X))^{*}$, the following statement holds for any $e\in\mathit{evts}(t)$ by definition:

[TABLE]

Let $t^{\prime}=t\project\alpha(P\|_{m_{1}}Q)$. For any event $e^{\prime}\in events(t^{\prime})$, there must exist some event $e\in events(t)$ such that $e^{\prime}=e\cap\alpha(P\|_{m_{1}}Q)$. Thus, by the first conjunct in (B), $e^{\prime}\in events(P\|_{m_{1}}Q)$. Since $t^{\prime}$ consists of only events in $events(P\|_{m_{1}}Q)$, it follows that $t^{\prime}\in(events(P\|_{m_{1}}Q))^{*}$. Along with Conditions (2) and (3), and (A), we can further conclude that

[TABLE]

Adding Conditions (1) and (4), we derive

[TABLE]

which implies $t\in traces(X)$, as required. ∎

Lemma A.3**.**

Given processes $P$, $Q$, and $R$, let $Y=P\|_{m_{1}}(Q\|_{m_{2}}R)$. Then, for any trace $t\in T(L)$, $t\in\mathit{beh}(Y)$ if and only if all the following conditions hold:

$t\in(events(Y))^{*}$** 2. 2.

$(t\project\alpha(P))\in\mathit{beh}(P)$** 3. 3.

$(t\project\alpha(Q))\in\mathit{beh}(Q)$** 4. 4.

$(t\project\alpha(R))\in\mathit{beh}(R)$**

Proof.

The proof is symmetric to that of Lemma A.2 and thus is omitted. ∎

Theorem A.4**.**

Given processes $P$, $Q$, and $R$, let $X=(P\|_{m_{1}}Q)\|_{m_{2}}R$ and $Y=P\|_{m_{3}}(Q\|_{m_{4}}R)$. If $\mathit{evts}(X)=\mathit{evts}(Y)$, then $X=Y$.

Proof.

Note that $\alpha(X)=\alpha(P)\cup\alpha(Q)\cup\alpha(R)=\alpha(Y)$. Along with the assumption that $\mathit{evts}(X)=\mathit{evts}(Y)$, it remains to show that $\mathit{beh}(X)=\mathit{beh}(Y)$. Consider an arbitrary trace $t\in\mathit{beh}(X)$. By Lemma A.2, the following four conditions hold:

$t\in(events(X))^{*}$ 2. 2.

$(t\project\alpha(P))\in\mathit{beh}(P)$ 3. 3.

$(t\project\alpha(Q))\in\mathit{beh}(Q)$ 4. 4.

$(t\project\alpha(R))\in\mathit{beh}(R)$

Since $\mathit{evts}(X)=\mathit{evts}(Y)$, we can apply these conditions to Lemma A.3 to derive that $t\in(events(Y))^{*}$. Thus, $\mathit{beh}(X)=\mathit{beh}(Y)$ and consequently, $X=Y$. ∎

From Theorem A.4, we can derive a more restricted version of the condition under which the composition operator is associative:

Corollary A.5**.**

Given processes $P$, $Q$, and $R$, let $X=(P\|_{m_{1}}Q)\|_{m_{2}}R$ and $Y=P\|_{m_{1}}(Q\|_{m_{2}}R)$. If $\mathit{evts}(X)=\mathit{evts}(Y)$, then $X=Y$.

Proof.

It follows as a special case of Theorem A.4 with $m_{3}=m_{1}$ and $m_{4}=m_{2}$. ∎