8.2 Towards a More Flexible Framework
The more flexible typing schemes are allowed, however, the more complicated becomes the definition of state equivalence. For example, if security types may refer to arbitrary domain fields and variables, such as a field whose type is the value of anfδfield of a different object, the object equivalence relation cannot be defined on a local per-object basis anymore. Moreover, it becomes harder to ensure that the typing rules are monotone and well-founded. For these reasons, I have refrained from these extensions to the type dependencies.
Updatingxδandfδ The type system prevents updates toxδvariables and fδfields.
It should be noted, however, an assignmentxδ:=`is fine as long as the contents of xδbefore the assignment is lower than the domain it is updated with, that is, the evaluation of`. The same applies to thefδfield of an object. For example, a public Bufferobject that has the domainLOWin itsfδfield could be reclassified at runtime to become confidential, simply by setting itsfδfield to the domainHIGH. Since the confidentiality level of data is increased, the program stays universally noninterferent.
The type system can check this “upwards” assignment by imposing condition of the formxδvQ`for such updates.
Erasure and declassification in DSD Updating domain fields and variables also en-ables other security-related operations. For example, information in aBufferobject can be erased by overwriting thecontentsfield with a harmless value and then setting
fδtoLOW. This scenario is secure, but not typable with the presented type system.
Setting fδto a lower value without overwriting thecontentsfield amounts to a de-classification of data. Indeed, the explicit change of security types in form of overwriting
fδfields resembles the manipulation of flow locks in the paralocks approach [BS10]
(albeit with less syntactic overhead). It should thus be interesting to integrating their semantic security formalization based on increasing attacker knowledge to find an appropriate weakening of universal noninterference.
Security polymorphism The universal noninterference property states that a pro-gram is noninterferent for any values the domain variablesxδand domain fields fδ have, and for any security policy. It would be interesting to explore other techniques beyond DSD to express and verify that a program is secure for a larger number of security environments.
Interestingly, flow-sensitive systems [HS06; Ber10] can be used for this purpose: they can infer fine-grained dependencies between input and output values, for example, that the final value of variableydepends on the initial value of variablex. Thus, the program is secure (at least for variabley) for any concrete security environment that assignsxa lower security domain thany.
8.2 Towards a More Flexible Framework In general, there are different ways to use generalized types for information flow security for multiple security environments: DSD and Jif allow a program to adapt its behaviour according to the required type, while flow-sensitive systems take a standard program and determine the set of concrete types that can be assigned to it. This observation supports the idea that there is a connection to the different manifestations of classic data type polymorphism.
Types derived by flow-sensitive systems loosely correspond to parametric poly-morphism: They express data dependencies and thus provide a schema that can be instantiated to concrete security level types, similar to parametric polymorphism, where universally quantified type schemata can be instantiated to concrete data types.
Privacy-aware programs, in contrast, can execute different code for different se-curity environments, such that the effective policy can always be respected. There is a connection to inheritance polymorphism in object-oriented languages, where dynamic method dispatch can be used to always choose that method implementation which respects the invariants of the respective dynamic class. The explicit label check construct in DSD and Jif, however, seem to correspond most closely to intensional polymorphism with type introspection [HM95], where the type of some data can be inspected at runtime using a specialtypecaseconstruct. The static analysis of the construct can use the refined type information for each case, just as my type system used the information about the inspected flow in the constraint set of thethenbranch.
Due to these parallels, it seems a promising approach to elaborate the works in the field of data type polymorphism, and examine to what extend they can be applied to type-based information flow analysis. This could provide a starting point to certify programs for a much wider range of user-defined security settings, including Dave’s and Sue’s.
Correctness Proof for the High-Level Type A
System
This appendix contains the complete soundness proof for the high-level type system. It is split into two parts: in the first part, the correctness of labels assigned by expression typing judgements is shown. The second part shows that typable statements are uni-versally noninterferent; the main correctness theorem for well-typed programs follows as a corollary.
Unless otherwise noted, the identifiers and indices used in the proofs directly refer the respective identifiers and indices used in the operational semantics and the typing rules. Moreover, we simplify notation and ignore the class information of objects. That is, given a heaphand a locationr,h(r) shall refer directly to the field valuation.
A.1 Expression Typing Soundness
The following lemma states that the expression typing rules are sound, that is, if they assign to an expression a label whose evaluations in two equivalent states are visible, then the expression evaluates to indistinguishable values in both states.
Lemma A.1 IfΓ` e : `, then for all statesσ=(s,h)andσ0=(s0,h0), for all partial bijectionsβ, for all domain lattices¦and all domains k∈Dom¦such that `¦σ∼Γ,kβ σ0, ifJ`K
¦σ≤¦k andJ`K
¦σ0≤¦k, thenJeK
¦σ∼βJeK
¦σ0. PROOF By induction overe.
• e=nore= >ore= ⊥. Theneis a constant andJeK
¦σ∼βJeK
¦σ0 holds.
• e=x. Then`=Γ(x). With Lemma 3.1 on page 33, we have〈Γ(x)〉¦s=JΓ(x)K
¦σ≤¦k, thus by definitions(x)∼βs0(x), henceJxK
¦σ∼βJxK
¦σ0.
• e=π.f.Γ` π : `πand`=Φπ(f)t`π. SinceJ`K
¦σ≤¦kandJ`K
¦σ0 ≤¦k, we get J`πK
¦σ≤¦kandJ`πK
¦σ0≤¦kand by inductionJπK
¦σ∼βJπK
¦σ0. We definer=JπK
¦σ
andr0 =JπK
¦σ0. Fromr ∼β r0 follows `¦h(r)∼kβ h0(r0). With Lemma 3.1 on page 33, we know
Φ(f)®¦
r =JΦπ(f)K
¦σ, which is lower thank sinceJ`K
¦σ≤¦k.
With the definition of object equivalence, we haveh(r)(f)∼βh0(r0)(f) and thus Jπ.fK
¦σ∼βJπ.fK
¦σ0.
• e=e1◦e2. We haveΓ` e1 : `1andΓ`e2 :`2and`=`1t`2. SinceJ`K
¦σ≤¦k andJ`K
¦σ0≤¦k, the same holds for the sublabels`1and`2. Therefore, we can apply the lemma inductively, and getJe1K
¦σ∼βJe1K
¦σ0andJe2K
¦σ∼βJe2K
¦σ0. Since the language does not feature any pointer operations, we have indeed equalities, and thus getJe1◦e2K
¦σ=Je1◦e2K
¦σ0, henceJeK
¦σ∼βJeK
¦σ0.
We now show that the labelling functionlabelofΓis monotone and well-founded.
Lemma A.2 If Γ` e : `andΓ``: `0, then`0v;`. PROOF By induction overe.
• e=nore∈{>,⊥}. Then`= ⊥, hence`0= ⊥. The label order⊥ v;`follows by definition.
• e=x. Then`=Γ(x)∈{xδ,>,⊥}, thus`0∈{Γ(xδ),⊥,⊥}={⊥}. The label order
⊥ v;`follows by definition.
• e=π.f. Then`=labelofΓ(π.f)=Φπ(f)tlabelofΓ(π). It follows
`0=labelofΓ(Φπ(f)tlabelofΓ(π))=labelofΓ(Φπ(f))tlabelofΓ(labelofΓ(π)).
Sinceπis a subexpression ofe, we can apply the lemma inductively and get labelofΓ(labelofΓ(π))v;labelofΓ(π). (*)
We now make a case distinction onΦπ(f):
– IfΦπ(f)∈{⊥,>}, thenlabelofΓ(Φπ(f))= ⊥.
– IfΦπ(f)=π.fδ, thenlabelofΓ(Φπ(f))= ⊥ tlabelofΓ(π).
It followslabelofΓ(Φπ(f))v;labelofΓ(π). Together with (*), we get`0v;`.
• e=e1◦e2. Then`=`1t`2and`0=`01t`02. By induction`01v;`1and`02v;`2,
we get`0v;`.
A.1 Expression Typing Soundness Lemma A.3 For all expressions e∈Exp, there exists an n∈Nsuch that for all m≥n, labelofmΓ(e)≡;⊥.
PROOF By induction overe. It suffices to show that there exists a numbern∈Nsuch thatlabelofnΓ(e)≡;⊥, because all subsequent applications oflabelofΓdo not change the label, due toΓ` ⊥: ⊥.
• e=nore∈{>,⊥}. Thenn=1, becauselabelofΓ(e)= ⊥.
• e=x: Then n=2, sincelabelofΓ(x)∈{xδ,⊥,>} andlabelofΓ(labelofΓ(x))= ⊥.
• e=π.f: By induction, there existn0∈Nsuch that for allm≥n0,labelofmΓ(π)≡;⊥.
Letn=n0+1. Then
labelofnΓ(π.f) ≡; labelofnΓ0(labelofΓ(π.f))
≡; labelofnΓ0(Φπ(f)tlabelofΓ(π))
≡; labelofnΓ0(Φπ(f))tlabelofΓ(labelofnΓ0(π))
≡; labelofnΓ0(Φ(f)[π.fδ/fδ])t ⊥ (by induction)
≡; labelofnΓ0(Φ(f)[π.fδ/fδ]) We now make a case distinction overΦ(f).
– Φ(f)∈{⊥,>}. ThenΦπ(f)∈{>,⊥}, hence by definitionlabelofnΓ0(Φ(f))≡;⊥ (becausen0>1).
– Φ(f)=fδ. Then
labelofnΓ0(Φ(f)[π.fδ/fδ]) ≡; labelofnΓ0(π.fδ)
≡; labelofnΓ0−1(labelofΓ(π.fδ))
≡; labelofnΓ0−1(Φπ(fδ)tlabelofΓ(π))
≡; labelofnΓ0−1(⊥ tlabelofΓ(π))
≡; labelofnΓ0(π)
≡; ⊥ (by induction).
• e1ope2. Then there existn1,n2 such that by inductionlabelofnΓi(ei)≡;⊥for i∈{1, 2}. Letn=max(n1,n2). ThenlabelofnΓ(e1ope2)≡;⊥.
For the soundness proofs of statement typing rules, we need a corollary that follows directly from meta-label monotonicity (Lemma A.2), well-foundedness (Lemma A.3), and soundness of expressions (Lemma A.1).
Corollary A.4 IfΓ` e : `, then for all statesσandσ0and all partial bijectionsβ, for all domain lattices¦and all domains k∈Dom¦such that `¦σ∼Γβ,kσ0,J`K
¦σ≤¦k implies J`K
¦σ=J`K
¦σ0.
PROOF By contradiction. SupposeJ`K
¦σ6=J`K
¦σ0. Then by definitionJ`K
¦σ6∼βJ`K
¦σ0. (*) Let Γ` ` : `0, i.e.labelofΓ(`) =`0. We get with Lemma A.2 that`0v;`. Since σ|=¦;, we get with the label order soundness theorem 3.3 thatJ`0K
¦σ≤¦J`K
¦σ≤¦k. By Lemma A.1 and with (*), it must beJ`0K
¦σ06≤¦k. We thus getJ`0K
¦σ6=J`0K
¦σ0. We can repeat this argument arbitrarily often and get that for alln,JlabelofnΓ(`)K
¦σ06≤¦k. However, this contradicts Lemma A.3, which says there is some n such thatlabelofnΓ(`)= ⊥, i.e.
JlabelofnΓ(`)K
¦σ0=k>¦≤¦k.