Calculi and Types for Global Computing (talk)

(1)

(Calculi and Types for)

Global Computing

FOUNDATIONS OF SECURITY

Oregon (23.6.03)

(2)

Foundations of Global Computing

Global Computing:

computation over a global network of mobile, bounded resources shared among mobile entities which move between

highly dynamic, largely unknown, untrusted networks.

Difficulties:

Extreme dynamic reconfigurability; lack of coordination and trust; limited

capabilities; partial knowledge . . .

Issues:

(3)

Foundations of Global Computing

Global Computing:

computation over a global network of mobile, bounded resources shared among mobile entities which move between

highly dynamic, largely unknown, untrusted networks.

Difficulties:

Extreme dynamic reconfigurability; lack of coordination and trust; limited

capabilities; partial knowledge . . .

Issues:

Protection and management of resources;

Mobility & Agent Migration

Globality & Variability

Resource Sharing & Control

(4)

Overview of the Lectures

Aim:

Illustrate calculi which formalise these ideas and pave the ground for the

development of foundations solid enough to underpin future applications.

Approach:

Present tools – essentially type systems – to guarantee safety, security and in

particular resource access control.

What:

➤ _{Name Mobility}

➤ _{Types for Safety & Control} ➤ _{Asynchrony & Distribution} ➤ _{Ambient Mobility}

(5)

Aim:

Approach:

What:

➤ _{Types for Safety & Control}

The π _Calculus:

➤ _{Basic calculus} ➤ _Variations

(6)

Aim:

Approach:

What:

➤

Typed π _Calculi:

➤ Sorts

➤ _{Simply Typed} _π ➤ I/O Types

(7)

Overview of the Lectures

Aim:

Approach:

What:

Asynchronous π Calculi:

➤ _π_A

➤ _Asynchronous _≈ ➤ _π_L

➤ _Dπ

(8)

Overview of the Lectures

Aim:

Approach:

What:

➤

Ambient Calculi:

➤ _{Mobile Ambients} ➤ Ambient Types ➤ _{Boxed Ambients} ➤ _{Types for}

(9)

Overview of the Lectures

Aim:

Approach:

What:

Resource Control

➤ _{Interferences}

(10)

Roadmap

➤ _{Another way to look at the plan:}

Start from π and move towards asynchrony and distribution.

N BA distributed

O

asynchronous//

7 7 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w 7w Dπ M A π πA join BA

➤

What will we ignore?

(11)

Global Computing

— Lecture I —

Name Mobility

(12)

Roadmap for Lecture I

➤ _The _π _{calculus’ basic mechanisms}

➤ _Examples ➤ _Variations

➤ _Polyadic _π ➤ _Summation

➤ _{Match & mismatch} ➤ _Recursion

(13)

The

π

calculus

The

π

calculus

is:

➤ _{A formal model to describe and analyse systems of interacting} (communicating)

processes

, with dynamic (re)configuration;

➤ _{Terms are processes, that is}

computational activities

_{running in parallel} with each other and possibly containing several independent subprocesses. ➤ Currently the

canonical model of concurrent computation

, as the

λ-calculus for functional computation:

➤ _{computation in the} _λ_{-calculus is the result of function application;} computation is the process of applying functions to arguments and yielding results:

(14)

Names in the

π

calculus

Naming

is a pervasive notion in

π

:

➤ _{It is a prerequisite to}

communication

_{and, therefore, interaction and} computation.

➤ _{It presupposes}

independence

_{: the} _namer _{and the} _named _{are independent} (concurrent) entities.

Names ‘name’

communication channels

(15)

Names in the

π

calculus

Naming

is a pervasive notion in

π

:

➤ _{It is a prerequisite to}

communication

_{and, therefore, interaction and} computation.

➤ _{It presupposes}

independence

_{: the} _namer _{and the} _named _{are independent} (concurrent) entities.

Names ‘name’

communication channels

(16)

The Syntax

➤ _{An infinite set of}

names

_: _N ₌ _{{x, y, z, . . .}}_. ➤

Action prefixes:

π ::= x(y) | xhyi | τ

➤

Processes:

P ::= X

i∈I

π_i.P_i | P | P | (νa)P | !P

where

➤ _I _finite;

➤ _input _x₍_y₎_.P _{and new} ₍_νy₎_.P _bind _y _in _P_{. Terms are taken up to} α-conversion. That is: for z not free in P

x(y).P ≡ x(z).P{z/y} (νy)P ≡ (νz)P{z/y};

(17)

Reductions

(νz)(¯xhyi + z(w).whyi |¯ x(u).uhv¯ i | xhz¯ i) (νz)(x¯hyi + z(w).whyi |¯ x(u).uhvi |¯ x¯hzi)

(νz)(0 | y¯hvi | xhz¯ i) (νz)(¯xhyi + z(w).whyi |¯ z¯hvi | 0)

(18)

Reductions

(19)

Reductions

(νz)(x¯hyi + z(w).whyi |¯ x(u).uhvi |¯ x¯hzi)

(20)

Reductions

(21)

Reductions

(22)

Reductions

(νz)(0 | y¯hvi | xhz¯ i) (νz)(¯xhyi + z(w).whyi |¯ z¯hvi | 0)

(23)

Contexts and Congruences

Process Contexts:

C _{::= [} _._] _| _π.C ₊ _P _| _(ν_a)C _| C _| _P _| _!C

Conguences:

A relation ./ is a congruence if it is preserved by all contexts, that is P ./ Q implies:

π.P + R ./ π.Q + R (νa)P ./ (νa)Q P | R ./ Q | R R | P ./ R | Q

(24)

Structural Congruence

P ≡ Q if they can be transformed into each other using

➤ _{rearrangement of terms in summations;} ➤ commutative monoidal laws for | (with 0 as unit);

➤

(νz)(P | Q) ≡ (νz)P | Q, if z 6∈ fn(Q); (νz)0 ≡ 0;

(νx)(νy)P ≡ (νy)(νx)P.

(25)

Structural Congruence

➤ _{rearrangement of terms in summations;}

➤ commutative monoidal laws for | (with 0 as unit); ➤

(26)

(27)

(28)

Standard Form

A process

(ν~a)(M₁ | · · · | M_m | !Q₁ | · · · | !Q_n) is in

standard form

if

1. each M_i is a sum and

2. each Qi is itself in standard form.

(29)

Reaction Rules

Tau: (τ.P + M) −→ P

React: (M + x(y).P) | (¯xhzi.Q + M0) −→ {z/y}P | Q

Par: P −→ P

0

P | Q −→ P0 | Q Res:

P −→ P0

(νa)P −→ (νa)P0

Struct: P ≡ P

0 _P0 _−→ _Q0 _Q0 _≡ _Q

(30)

An example

Although it may appear not obvious, the term

P = x(z).yhz¯ i | !(νy)¯xhyi.Q

(31)

An example

has a redex. Let us use ≡ to uncover it.

(32)

An example

P ≡ x(z).¯yhzi | (νy)(¯xhyi.Q) | !(νy)¯xhyi.Q

(33)

An example

≡ x(z).y¯hzi | (νa)(¯xhai.Q) | !(νy)¯xhyi.Q

(34)

An example

≡ x(z).¯yhzi | (νa)(¯xhai.Q) | !(νy)¯xhyi.Q

≡ (νa)(x(z).¯yhzi | xhai.Q)¯ | !(νy)¯xhyi.Q

(35)

Scope extrusion

The following rule enlarges the scope of a:

(νa)(P | Q) ≡ P | (νa)Q if a 6∈ fn(P)

➤ left-to-right reading: no surprise

➤ _{right-to-left reading: enables export of private names.} c(x).P | (νa)chai.Q

In such form, the processes may not communicate. However:

c(x).P | (νa)chai.Q ≡ (νa)(c(x).P | chai.Q)

−→ (νa)(P{a/x} | Q)

the name a, private to Q, has been communicated to P.

(36)

Scope extrusion

The following rule enlarges the scope of a:

(νa)(P | Q) ≡ P | (νa)Q if a 6∈ fn(P)

➤ left-to-right reading: no surprise

➤ _{right-to-left reading: enables export of private names.} c(x).P | (νa)chai.Q

In such form, the processes may not communicate. However:

c(x).P | (νa)chai.Q ≡ (νa)(c(x).P | chai.Q)

−→ (νa)(P{a/x} | Q)

the name a, private to Q, has been communicated to P.

(37)

Scope extrusion, continued

The reduction

c(x).P | (νa)chai.Q −→ (νa)(P{a/x} | Q)

establishes a new communication link between P and Q, viz. a.

The new link is now

private

to P and Q, and will remain so until one of them communicates it to third parties.

Scope extrusion and channel-based communication provide an elementar, yet powerful mechanism for:

➤

Name mobility

_{: dynamically changing the topological structure of a system} of processes, by creating new communication links.

(38)

The essence of name mobility

P

8?9>:=;<

x z

? ? ? ? ? ? ? ?

?

8?9>:=;<

Q

R

8?9>:=;<

(39)

P

8?9>:=;<

x z

? ? ? ? ? ? ? ?

?

8?9>:=;<

Q

R

8?9>:=;<

(40)

P

8?9>:=;<

x z

? ? ? ? ? ? ? ?

?

8?9>:=;<

Q

R

8?9>:=;<

(νz)(P | R) | Q

(41)

P

8?9>:=;<

x z ? ? ? ? ? ? ? ?

?

8?9>:=;<

Q

R

8?9>:=;<

(νz)(P | R) | Q

P

8?9>:=;<

x Q

8?9>:=;<

z ÄÄÄÄ ÄÄÄÄ Ä R

8?9>:=;<

P0 | (νz)(R | Q0)

(42)

Name mobility and secret channels

A simple

security protocol

:

➤ _A_{lice and} _B_{ob want to exchange secret} _M_, _S_{erver mediates.}

A and B share private channels c_AS and c_BS with S

➤ _A _sends _B _{a secret channel} _c_AB _via _S_.

Msg 1: A → S c_AB on c_AS

Msg 2: S → B c_AB on c_BS ➤ _Now _A _and _B _{communicate via} _c_AB_.

Msg 3: A → B M on cAB

π

-calculus

specification

of the protocol

A , (νc_AB)c_AShcABi.cABhMi

S , c_AS(x).c_BShxi

B , c_BS(x).x(y).P{y}

(43)

Name mobility and secret channels

A simple

security protocol

:

➤ _A_{lice and} _B_{ob want to exchange secret} _M_, _S_{erver mediates.}

A and B share private channels c_AS and c_BS with S

➤ _A _sends _B _{a secret channel} _c_AB _via _S_.

Msg 1: A → S c_AB on c_AS

Msg 2: S → B c_AB on c_BS ➤ _Now _A _and _B _{communicate via} _c_AB_.

Msg 3: A → B M on cAB

π

-calculus

specification

of the protocol

(44)

A run of the protocol

SYS = cBS(x).x(y).P{y} | cAS(x).cBShxi | (νcAB)(cAShcABi.cABhMi)

≡ cBS(x).x(y).P{y} | (νcAB)(cAS(x).cBShxi | cAShcABi.cABhMi)

−→ c_BS(x).x(y).P{y} | (νc_AB)c_BShc_ABi | c_ABhMi)

≡ (νcAB)(cBS(x).x(y).P{y} | cBShcABi | cABhMi)

(45)

The run, conceptually

A = (νc_AB)c_AShc_ABi.c_ABhMi

S = c_AS(x).c_BShxi

B = cBS(x).x(y).P{y}

A

8?9>:=;<

cAS ? ? ? ? ? ? ? ?

?

8?9>:=;<

B

cBS ÄÄÄÄ ÄÄÄÄ Ä S

8?9>:=;<

=⇒

A = c_ABhMi

S = 0

B = cAB(y).P{y}

(46)

But of course ...

➤ _{This is an ideal picture, as private channels are an abstraction} (νn)(nhaiQ | n(x).P)

➤ _{What if the two processes are located at remote sites?} ➤ _{In practice, one needs cryptography}

(νn)(ph{a}niQ | p(y).decrypt y as {x}n in P)

(47)

Polyadic

π

The idea:

x(y1, . . . , yn).P | xhz¯ 1, . . . , zni.Q → {~z/~y}P | Q

Is it a more expressive paradigm? Or can it be encoded?

Encoding?

xxhz¯ ₁, z₂i.Py = ¯xhz₁i.xhz¯ ₂i.xPy.

Right idea:

pxhz¯ ₁, z₂i.Pq = (νz)¯xhzi.¯zhz₁i.¯zhz₂i.pPq px(z1, z2).Pq = x(y).y(y1).y(y2).pPq

(48)

Polyadic

π

The idea:

Encoding?

Right idea:

(49)

Polyadic

π

The idea:

Encoding?

Wrong idea:

xxhz¯ 1, z2i.P | x(y1, y2).Q1 | x(y1, y2).Q2y

−→∗

xPy | x(y₂).{z₁/y₁}xQ₁y | x(y₂).{z₂/y₂}xQ₂y

Right idea:

pxhz¯ 1, z2i.Pq = (νz)¯xhzi.¯zhz1i.¯zhz2i.pPq

px(z₁, z₂).Pq = x(y).y(y₁).y(y₂).pPq

(50)

Polyadic

π

The idea:

Encoding?

Right idea:

(51)

Example: memory cells

cell(n) , (νs)(shni |

!_get(y).s(x).(shxi | yhxi) |

!_put(y, v).s(x)(shvi | yhi))

➤ _{a private channel} _s _{‘stores’ the value} _n _{(it represents the state of the} memory cell),

➤ _{two handlers serving the ‘}

get

_{’ and ‘}

put

_{’ requests.}

➤ _{both implemented as replicated processes, to serve multiple requests.} ➤ _{each request served by first spawning a fresh copy of the handler by}

(52)

Cell: put and get

get(y).s(x).(shxi | yhxi)

➤ _{receive on} _get _{the name} _y _{of a channel where to send back the result}

➤ _{upon receiving the channel name, consume the current cell value, and then} reinstate it while copying it to the channel y;

put(y, v).s(x)(shvi | yhi)

(53)

Cell and User

A sample user of the cell:

client(v) = (νack)(νret)

puthack, vi.ack()._geth_reti._ret(x)._printhxi

➤ _{declare private return and ack channels}

➤ _{first write a new value, wait for ack, and then read the cell contents to} print the returned value.

Let us look at the system:

(54)

Cell & user: reduction

(sh0i | (_put(y, v).s(x). . . . | . . .))_cell | (_puth_ack,1i. . . .)_user

−→ (sh0i | s(x).(sh1i | _ackhi) | . . .))_cell | (_ack(). . . .)_user

−→ (sh1i | _ackhi | . . .)cell | (ack(). . . .)user

−→ (sh1i | (_get(y).s(x). . . .))cell | (gethreti. . . .)user

−→ (sh1i | (s(x).(shxi | _rethxi). . .))cell | ret(x).printhxi

−→ (sh1i | _reth1i. . .)_cell | _ret(x)._printhxi

−→ (sh1i | . . .)_cell | _printh1i

(55)

Summation

The original calculus has

unguarded sums

:

P ::= . . . | P + P

This makes the theory more complex while producing little gains in expressiveness.

Input guarded sum:

Pi∈I xi(y).P

Rejects things like (x.P + y.Q)¯ | (x¯.P0 + y.Q0).

No sums at all:

Still, purely internal choice τ.P + τ.Q can be defined:

(56)

Matching and Mismatching

The original calculus has

π ::= . . . | [x = y]π | [x 6= y]π

[x = x]P ≡ P [x 6= y]P ≡ 0

Useful in programming, it has an impact on the theory, and somehow complicates it. A general encoding is impossible, but in some cases its effect can be recovered to a certain extent:

xa(x).(P_i[x = ki]Pi)y = a(x).(¯xhi | P_i ki().xPiy)

(57)

Recursive Definitions

It is useful to be able to write

A(~x) def= Q_A, where Q_A = · · · Ahwi · · ·~ Ahwi · · ·~

It can be obtained using replication as follows 1. Choose aA to stand for A;

2. Rb = replace Ahwi~ with a¯_Ahwi~ in R; 3. Pbb = (νaA)(Pb | !aA(~x).QcA).

On the other hand, replication can be defined from recursive defs.

(58)

Higher Order

π

A most natural suggestion for process mobility:

π ::= · · · | x(X) | x¯hPi

P ::= · · · | X

(59)

Higher Order

π

π ::= · · · | x(X) | x¯hPi

P ::= · · · | X

x(X).P | xhRi.Q¯ → {R/X}P | Q

¯

ah¯bhuii.b(x) | a(X).(X | chv¯ i) → b(x) | ¯bhui | chvi.¯

This is very expressive: A general purpose replicator

(60)

Higher Order

π

π ::= · · · | x(X) | x¯hPi

P ::= · · · | X

x(X).P | xhRi.Q¯ → {R/X}P | Q

Thm.

Encoding ‘fully abstract’. Assume a name an unused name x associated to each X.

[[ahPi.Q]] = (νp)ahpi.([[Q]] | !p.[[P]]), p fresh [[a(X).P]] = a(x).[[P]])

(61)

Other variants

➤ _Asynchronous _π_: _{Disallow continuation on sending} _ahxi.P_. ➤ _Local _π_: _{Disallow inputs on} _x _{in the body of} _a₍_x₎_.P_.

➤ _Private _π_: _{Disallow output of free names: Processes can only pass names} their own private names.

➤ _Distributed _π_: Several interesting calculi based on πA: Dpi, Join, Blue, Seal,

(62)

Observations and Bisimulation

Observations:

P↓_a if P can engage in action involving a

P↓a , P ≡ (ν~x)(ahzi.P0 + · · · ) a 6∈ ~x P↓a , P ≡ (ν~x)(a(z).P0 + · · · ) a 6∈ ~x P⇓α , P =⇒↓α (=⇒ , −→∗)

Barbed Bisimulation

≈

.

:

is the largest equivalence relation t s.t. for all P t Q ➤ _If _P _−→ _P0 _then _Q ₌_⇒ _Q0 _{for some such that} _P0 _t _Q0_;

➤ _If _P_↓_x_{, then} _Q⇓_x Barbed bisimulation is very weak, pretty useless:

ahui ≈. ahvi ≈. (νu)ahui

(63)

Observations and Bisimulation

Observations:

P↓_a if P can engage in action involving a

P↓a , P ≡ (ν~x)(ahzi.P0 + · · · ) a 6∈ ~x P↓a , P ≡ (ν~x)(a(z).P0 + · · · ) a 6∈ ~x P⇓α , P =⇒↓α (=⇒ , −→∗)

Barbed Bisimulation

≈

.

:

is the largest equivalence relation t s.t. for all P t Q ➤ _If _P _−→ _P0 _then _Q ₌_⇒ _Q0 _{for some such that} _P0 _t _Q0_;

➤ _If _P_↓_x_{, then} _Q⇓_x

Barbed bisimulation is very weak, pretty useless:

(64)

Observations and Contexts

Barbed equivalence is very weak, but ‘contexts’ are very powerful enquirers: Consider C _{= (}_νa_{)([ ]} _| _a₍_x₎_.x_{). Then}

C_[¯_ahui_] _→ ₍_νa₎_u _↓_u C_[¯_ahvi_] _→ ₍_νa₎_v _↓_v C_[(_νu_)¯_ahui_] _→ _(ν_au₎_u_{6 ↓}

Therefore C_[¯_ahui_] ₆_≈. C_[¯_ahvi_] ₆_≈. C_[(_νu_)¯_ahui_]

Barbed Congruence

∼=c: Is the largest congruence in ≈. , that is

P =∼c Q iff C_[_P_] _≈. C_[_Q_]_, _{for all} C_.

Context Lemma:

P ∼=c Q iff P σ | R ≈. Qσ | R, for all R and substitutions σ.

(65)

Barbed Congruence

Context Lemma:

(66)

Barbed Congruence

Context Lemma:

(67)

Barbed Congruence

(68)

The problem with aliasing

Role of σ is account for

aliasing

occurring from rebinding of names after input.

Consider that x | y ≈. x.y + y.x. But, in C ₌ _a(y).[_._] _| _{ahxi, since} _x _{is received for} _y, _x _| _x ₆_≈. _x.x ₊ _x.x_.

The effect of such contexts is captured by the context lemma σ(x) = σ(y) = z. Similar problems for matching:

(69)

The problem with aliasing

aliasing

Consider that x | y ≈. x.y + y.x.

But, in C ₌ _a(y).[_._] _| _{ahxi, since} _x _{is received for} _y, _x _| _x ₆_≈. _x.x ₊ _x.x_.

(70)

The problem with aliasing

aliasing

Consider that x | y ≈. x.y + y.x.

But, in C ₌ _a(y).[_._] _| _{ahxi, since} _x _{is received for} _y, _x _| _x ₆_≈. _x.x ₊ _x.x_.

(71)

Labelled Transition System

➤ Barbed bisimulation derives

naturally

from the

reduction

rules. ➤ _{Congruences are brought about by engineering, mathematical and logical}

considerations.

➤ But barbed congruence is

hard

to work with.

➤

Desiderata:

_{Characterise it in terms of:}

1. bisimulations (easy to reason with –

coinduction

)

(72)

naturally

from the

reduction

rules.

➤ _{Congruences are brought about by engineering, mathematical and logical} considerations.

hard

to work with.

➤

Desiderata:

coinduction

)

(73)

naturally

from the

reduction

rules.

hard

to work with. ➤

Desiderata:

coinduction

)

(74)

naturally

from the

reduction

rules.

hard

to work with.

➤

Desiderata:

Characterise it in terms of:

coinduction

)

(75)

π

Actions

α ::= τ | xy | νxy | xy

➤ _n₍_α_{): names in} _α

➤ _bn₍_α_{): names bound in} _α_{, that is bound output.}

Desiderata:

Thm:

Establish a compositional −−α→ such that −−τ→≡ = −→

(76)

(Out)

xhyi.P −−−xy→ P

(Inp)

x(z).P −−−xy→ P{y/z}

(Tau)

τ.P −−τ→ P

(Open)

P −−−xz→ P0

x6=z (νz)P −−−−νxz→ P0

(CloseL)

P −−−−νxz→ P0 Q −−−xz→ Q0

z6∈fn(Q)

P | Q −−τ→ (νz)(P0 | Q0)

(CommL)

P −−−xz→ P0 Q −−−xz→ Q0

P | Q −−τ→ P0 | Q0

(SumL)

P −−α→ P0

P + Q −−α→ P0

(ParL)

P −−α→ P0

bn(α)∩fn(Q)=∅

P | Q −−α→ P0 | Q

(Res)

P −−α→ P0

z6∈n(α) (νz)P −−α→ (νz)P0

(Rep)

P | !P −−α→ Q

(77)

An example

Let us show how to prove that

x(y).P | (νa)xhai.Q −−τ→ (νa)(P{a/y} | Q) x(y).P −−−xa→ P{a/y}

xhai.Q −−−xa→ Q

(νa)xhai.Q −−−−νxa→ Q

x(y).P | (νa)xhai.Q −−τ→ (νa)(P{a/y} | Q)

The role of _Open, _Close, and _Comm: