{'fraction_non_alphanumeric': 0.03180040535525677, 'fraction_numerical': 0.004795752333647341, 'mean_word_length': 4.574793125397836, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Analysing Flow Security Properties in Virtualised Computing Systems

This paper studies the problem of reasoning about flow security properties in virtualised computing networks with mobility from perspective of formal language. We propose a distributed process algebra CSP_{4v} with security labelled processes for the purpose of formal modelling of virtualised computing systems. Specifically, information leakage can come from observations on process executions, communications and from cache side channels in the virtualised environment. We describe a cache flow policy to identify such flows. A type system of the language is presented to enforce the flow policy and control the leakage introduced by observing behaviours of communicating processes and behaviours of virtual machine (VM) instances during accessing shared memory cache.


Introduction
Cloud computing has attracted interests in both the scientific and the industrial computing communities due to its ability to provide flexible, configurable, and cost-effective computing resources delivered over the internet. In cloud systems, computing resources are shared among multiple clients. This is achieved by virtualisation in which a collection of virtual machines (VMs) are running upon the same platform under the management of the hypervisor. Virtualisation allows computing service providers to maximise the utilisation of the devices and minimise the costs by creating multiple VMs over a shared physical infrastructure. However, such services can also bring additional channel threat, and introduce information leakage between unrelated entities during the procedure of resource sharing and communications through unintended covert channels. To address this concern, this paper proposes to develop formal approaches to specifying, modelling and analysing flow security properties in virtualised computing networks, which are the key underpin of contemporary society such as cloud computing.
Specifically, information leakage can come from observations on both program executions and cache usage in the virtualised environment. On the one hand, for processes running upon a particular VM instance, consider the processes are communication channels, sensitive inputs can be partially induced by observing public outputs of the processes regarding choices of public inputs. On the other hand, shared caches enable competing VM instances to extract sensitive information from each other. CPU cache, a small section of memory built in the CPU for fast memory access, is one of the highest-rate measurable resources shared by multiple processes [32]. Therefore cache-based side-channel attack becomes one of the major attack on VMs and receives the most attention in the cloud environment [24]. Consider a malicious VM repeatedly access shared cache memory to perform cache-based side-channel attacks. Such attacks allow one virtual machine to effectively steal secrets of another hosted machine in the same cloud environment. More precisely, for processes running upon different VM instances, cache usage can be considered as a communication channel. Consider the cache lines accessed by the victim instance and by the malicious instance as high level input and low level input respectively, by observing the usage (such as time) of victim cache lines (low output), the malicious observer can learn some information of the victim instance. In summary, this paper considers distributed virtualised computing environment where the attacker VM steals the information from the target one by observing executions of victim processes, and by probing and measuring the usage (timing) of the shared cache.
In particular, we develop an approach from the software language-based level to enforce the applications to access shared cache and to bring interferences in a predictable way. As a result, we aim to prevent the leakage introduced by such cache timing channel and the interference between security objects caused by executions. First, we propose a CSP-like language for modelling communicating processes running upon VMs with mobility in the computing environment. Second, we formalise a cache flow policy to specify the security condition regarding the threat model we focus on. Finally, we describe a type system of the language to enforce the flow policy and control the leakage introduced by observing the system behaviours. More specifically, we give an identifying label to each VM instance, and partition the cache into a set of page-sized blocks, each block in pages is mapped to a set of cache lines and is dynamically granted the label of its owner (the VM instance it is allocated to). The label of the block will be revoked when its owner terminates. In addition, programming variables and cache lines are assigned security labels to denote the security levels of the data they store. VM instances and hosts are assigned to different categories for the purpose of controlling information flow introduced by processes and VM instances movements. When a guest VM is launched, the VM manager allocates cache pages to it regarding its requests. During the running time of the VM process, operation of cache lines is allowed only if it satisfies the specified flow policy. Processes are allowed to move from one VM to another, and VM instances are allowed to move from one host to another. However, movements from a lower-ordered category carrier to a higher one are not allowed. Furthermore, we only allow the communicating process access the cache within a certain time in order to prevent timing leaks by observing the usage of the cache. These regulations are enforced by the semantics and the typing rules we formalised. When the guest VM terminates, the relevant cache pages are initialised, and released to the VM manager to prevent flushing of the pages by a malicious VM.
Outline. This paper is organised as follows. Section 2 describes our language for modelling basic virualised computing networks. Section 3 describes the threat model we focus on. Section 4 specifies cache flow policy which the processes should satisfy in our model. Section 5 presents a type system to enforce the cache flow policy. Section 6 briefly reviews literature in the related areas.

The Modelling Language CSP 4v
This section presents a dialect of communicating sequential processes (CSP) [10] language CSP 4v for formal modelling of and reasoning about virtualised computing network systems considered in this paper. Such an environment can be considered as a distribute computing system, in which a group of inter-connected and virtualised computers are dynamically allocated for serving. Processes can move from one VM to another and communicate to each other via sending/receiving messages. Applications and data are stored and processed in the network but can be accessed from any location using a client. It is natural to specify and describe the system as a set of communicating processes in a network with consideration of resource sharing in a predictable way. A CSP-like language is therefore a good choice for modelling of such systems.

Terminology and notation
We consider the infrastructure consists of a set of virtual private networks (VPNs) upon which a set of virtual machines (VMs) can communicate with each other. A VPN may include one or more VMs, and the location of VMs can be viewed as a node (host) of the VPN it belongs to. An instance is a VM upon which a number of processes locate and run. Let I denote a set of instances, I = {I, I 1 , . . . , I n }. Processes (P, P 1 , . . . ) can be constructed from a set of atomic actions called events (e, e 1 , . . . ), or be composed using operators to create more complex behaviours. The full set of actions that a system may perform is called the alphabet (Σ). The operators are required to obey algebraic laws which can be used for formal reasoning. The interactions carrying data values between processes take place through "channels". From an information theory point of view, a storage device such as cache which can be received from (reading) and sent to (writing) is also a kind of communication channel. CPU data caches locate between the processor cores and the main memory. We assume the clients (including the attacker) know the map between memory locations and cache sets, so we omit the details of the mapping and focus on cache organisation and operation here. Cache can be viewed as a set of cache lines: CLines = {l i |0 ≤ i ≤ n} where n denotes the size of the cache.
In addition, in order to encode the desired features of the language for flow secure virtualised computing systems, we assign security labels into variables and cache lines (channels), and allocate cache lines into instances via mappings: where L denotes a security lattice. We write τ in stead τ v and τ c in general for cases without introducing any confusion. Furthermore, we consider VM hosts are assigned to different categories Ω H , with an ordering of subset relations: For instance, h 1 is assigned to category: Ω 1 = {student}, h 2 is assigned to category: Ω 2 = {student, staff}, and thus h 1 ⊑ h 2 since Ω 1 ⊆ Ω 2 . Similarly, we also assign VM instances into different sub-categories Ω I , with an ordering of subset relations: For instance, P running upon VM i 1 belonging to sub-category: ω 1 = {UG-1} ⊆ student, Q running upon VM i 2 belonging to sub-category: ω 2 = {UG-1, UG-2} ⊆ student, and ω 1 ⊆ ω 2 , so i 1 ⊑ i 2 . Table 1 presents the syntax of the language CSP 4v . Expressions can be vari-  ables, channels, integers and arithmetic operations (denoted by ⊕) between expressions. Operator x := exp assigns the value of exp to process variable x. Action operator STOP denotes the inactive processes that does nothing and indicates a failure to terminate, and delayable operator SLEEP(∆t) allows the process to do nothing and wait for ∆t time units. Moving operator MOVE P (i) allows a process P to be able to move from current VM to another one i. We require that VM processes running upon on a VM instance with lower (category) order are not allowed to move to a VM instance with a higher (category) order. Operator P ; Q denotes the sequential composition of processes P and Q. Branch operator P ⊳b⊲Q defines if the boolean expression b is true then behaves like P otherwise behaves like Q. Sending operator a!(w) will output a value in expression w over channel a to an agent, and receiving operator a?x allows us to input a data value during an interaction over channel a and write it into variable x of an agent. P Q denotes the synchronous parallel composition of processes P and Q. Loop operator b ⊲ (P ) * denotes the loop operation of process P while b is true.

Syntax
An instance I is a virtual machine (VM) hosted on a network infrastructure. Operator [[P ]] defines the VM upon which process P runs. Operator MOVE I (h) allows VM instances (with all processes running on it) to migrate from current host machine to another host h to keep the instance running even when an event, such as infrastructure upgrade or hardware failure, occurs. Similarly to the process movement, we require that VM instances running upon on a host with lower (category) order are not allowed to move to a host with a higher (category) order. So, in the previous example, instances running upon h 1 are not allowed to moved to h 2 , and P is not allowed to move to VM i 2 . Operator i : [[I]].M I defines the host machine upon which I runs, M I denotes the cache pages allocated to instance I. To ensure that no cache is shared among different VM instances, we require that for any host h upon which any I 1 and I 2 are running:

Operational semantics
In order to incorporate as much parallel executions of events within different nodes as possible, we transform the network G into a finite parallel compositions of the form: .M kj is considered as a decomposition of G. We argue such decomposition is well-defined by applying the following rules of structural equivalence: We now define the operational semantics of CSP 4v in terms of multiset labelled transition system Γ , Σ, =⇒ , where: -Γ is a vector of configurations of a VPN G regarding the vector of decomposition of G. A configuration Γ , regarding a single component (say process P ) of the decompositions of G, is defined as a tuple (σ, δ, I, H), where: • σ : Vars P → Ints denotes the store; • δ : CAddr P → (Ints ∪ {∅}) defines the possible world regarding cache; • I specifies the owner (the VM instance identifier) of process P ; • H specifies the host (location) of the VM instance of process P . -Σ is a set of operating events which the processes can perform; -=⇒⊆ Γ × Σ × Γ is the multiset transition relations: Σ denotes a vector of operating events for the vector of components.
The action rules of the operational semantics of CSP 4v is presented in Table 2. Notations ⇒, ⇐, ⇓ denote cache addressing, cache allocation, and evaluation respectively. For instance, Γ ⊢ exp ⇓ v means that under configuration Γ , exp evaluates to value v, w ⇐ CAddr a means the cache allocated for expression w locates at CAddr a , and a ⇒ CAddr a means cache address of channel a is CAddr a , notation CAddr P is used to denote the cache addresses allocated for P .
Action rule of assignment x := exp, Γ updates the configuration such that the state of x is the value v of expression exp after the execution. Action rule of process moving operator MOVE P (i ′ ) updates the configuration such that the identifier of instance accommodating P turns to be i ′ after the execution of the process movement. Similar action rule is applied for VM instance movement from one host to another. Action rule of sending operator a!(w) updates the configuration such that the value stored in cache address (CAddr a ) is v, if expression w evaluates to v under configuration before the execution and the address of cache allocated for communicating channel a (to store expression w) is CAddr a . Rule of receiving operator a?x updates the configuration such that the state of variable x is v, if the value stored in cache address CAddr a of the communicating channel is v under the configuration before receiving the data. In the cross-VM communications over today's common virtualised platforms, the cache transmission scheme requires the sender and receiver could only communicate by interleaving Table 2. Operational semantics of CSP4v their executions for security concerns. In order to capture timing behaviour of cache-related operations, we consider the cache-related operations, such as communicating, as time-sensitive behaviours whose lasting time is recorded. The events are therefore considered as either non-delayable (time-insensitive, time does not progress) actions or delayable (time-sensitive, involves passing of time ∆t) behaviour. We use ∆t(e) to denote the time duration of event e lasting for.
The behaviour of a process component can now be viewed as a set of sequences of timed runs.
Definition 1 (Timed run). A timed run of a component of G is a sequence of timed configuration event pairs leading to a final configuration: where, Γ 0 and Γ denote the initial and final configuration respectively. ∀i ∈ {0, n}, e i is an event will take place with passing time ∆t i under configuration Γ i ; if ∆t i = 0, e i is considered as an immediate event, if ∆t i > 0, e i is considered as a time-sensitive event with lasting time ∆t i .

Attacker Model
We consider computing environment where malicious tenants can use observations on process executions and on the usage of shared cache to induce information about victim tenants. We assume the service provider and the applications running on the victim's VM are trusted. Let us consider the attacker owns a VM and runs a program on the system, and the victim is a co-resident VM that shares the host machine with the attacker VM. In particular, there are two ways in which an attacker may learn secrets from a victim process: by probing the caches set and measuring the time to access the cache line (through the cache timing channel), and by observing how its own executions are influenced by the executions of victim processes.
Cache timing side channel (C1). In the virtualised computing environment, different VMs launch on the same CPU core, CPU cache can be shared between the malicious VM and the target ones. Consider the malicious VM program repeatedly accesses and monitors the shared cache to learn information about the sensitive input of the victim VM. Specifically, timings can be observed from caches and are the most common side channels through which the attacker can induce the sensitive information of the victim VM. Intuitively, such cache side channel can be viewed as a communication channel, the victim and the attacker can be viewed as the sender and the receiver respectively. We assume that the attacker knows the map between memory locations and cache sets, and is able to perform repeated measurements to record when the victim process accesses the target cache line. We focus on cache timing side channel, all other side-channels are outside our scope. Example 1. Consider the scenario presented in Fig. 1, where VM 1 (victim VM, labelled i 1 ) and VM 2 (attacker VM, labelled i 2 ) be two instances running upon Host 1 (labelled h 1 ); victim processes P and Q, running over VM 1 , are communicating to each other: P generates a key and sends it to Q, Q encrypts a message using the received key and sends the encrypted message to P , P receives the message and decrypts it; and attacker process R, running over VM 2 , keeps probing cache address of the key. Let keyGen, encrypt and decrypt denote the function of generating a key, encryption and decryption respectively, and assume cread(CAddr) is a function probes cache address CAddr: returns 1 if it is available and returns −1 otherwise. We present the model in our language as The communication time between P and Q is affected by the value of the key generated. There is information flow from victim VM to malicious VM through cache side channel.
Leakage through observations on process executions (C2). Next let us focus on processes running upon a particular VM instance. Consider the VM instance, upon which processes are running, as a communication channel having inputs and outputs, which is relative to information flow from victim user to a malicious one. The victim user controls a set of higher level inputs with confidential data.
The attacker is an observer who may have control of lower level inputs. He has partial observation on executions of the process, but does not have any access to the confidential data. Specifically, the weak attacker can observe the public result, i.e., the final public output of the programs, while the strong attacker can observe the low state after each execution step of the processes. We consider a process has access to confidential data via higher level inputs. The attacker tries to collect and deduce some of the secure information about higher level inputs by varying his inputs and observing the execution of the process.
Example 2. Consider process P and R are running upon a VM instance VM.
Process P inputs a password through channel pwd into H-level variable x, and updates L-level variable y to be 1 if x is odd and to be 0 if x is even. Process R output variable y through channel res: Clearly there are implicit flows from x to y by observing L-level output of the process.

Information Flow Policy
Information flow is controlled by means of security labels and flow policy integrated in the language. Each of the identifiers, information container, is associated with a security label. Identifiers can refer to variables, communication channels, and can refer to entities such as files, devices in a concrete level. The set of the security labels forms a security lattice regarding their ordering. We study the system flow policy which prevents information flow leakage from high-level objects to lower levels and from a target instance to a malicious one via observing process executions and cache usage (by measuring the time of accessing cache lines during communications). In general, information flow policies are proposed to ensure that secret information does not influence publicly observable information. An ideal flow policy called Non-interference (NI) [8] is a guarantee that no information about the sensitive inputs can be obtained by observing a program's public outputs, for any choice of its public inputs. Intuitively, the NI policy requires that low security users should not be aware of the activity of high security users and thus not be able to deduce any information about the behaviours of the high users. On the one hand, for processes running upon a particular VM instance (regarding C2), the NI policy can be applied to control information flow from high-level input to low-level output, where state of sensitive information container (s.a. high-level variables) and observations on behaviours of public information container (s.a. low-level variables) are viewed as the high input and low output respectively. On the other hand, for processes running upon different VM instances (regarding C1), we adapt the NI policy here in order to control the information flow from processes running upon victim instance to malicious one through cache side channel. Consider the cache side channel as a communication channel, the cache lines accessed by the victim instance and by the malicious instance are viewed as high level input and low level input respectively, and the observations on the victim cache usage (s.a. hits/misses) are considered as low level outputs. Cache flow non-interference demands the changing of the cache lines accessed by the victim process (high inputs) does not affect the public observations on the cache usage (low outputs). Informally, cache flow interference happens if the usage (we focus on the accessing time) of the cache lines accessed by one victim process affects the usage of the cache lines accessed by attacker VM processes. Fig. 2 presents some intuition of the cache NI policy discussed above.

Definition 4 (Strong bisimulation
s ∼ Ξ,(t,ωI ,ωH ) and weak bisimulation w ∼ Ξ,(t,ωI ,ωH ) ). Consider two timed runs running upon host h under security environment Ξ: we say λ and λ ′ are strong (t, ω I , ω H )bisimilar to each other, i.e., λ s ∼ Ξ,(t,ωI ,ωH ) λ ′ , iff: and say λ and λ ′ are weak (t, ω I , ω H )-bisimilar to each other, i.e., λ w ∼ Ξ,(t,ωI ,ωH ) λ ′ , iff: Definition 5 (Cache flow security policy). Given a security level L ∈ L, ω H ⊆ Ω H , and ω I ⊆ Ω I a VPN G under security environment Ξ is considered strong cache flow secure iff: where Γ 0 and Γ ′ 0 denote the initial configuration of λ and λ ′ respectively, Λ denotes all runs of components of G. Similarly, the definition of weak cache flow secure can be given. In order to close the cache timing channel, we consider the communication as a scenario of sending and receiving processes running in parallel with certain time interleaving data transmission scheme: The communicating procedure needs to complete in T time units (together with sleeping time) and then behaves as P ; the value of w is sent to variable x via channel a, channel a and the relevant cache lines are then tagged as τ c (w). The communication will be considered as failed if T time units have passed but the communication has not completed yet. Fixed completion time T prevents the timing leakage introduced by the cache channel communication.
Example 4. Consider the model presented in Example 1, we rewrite the communicating procedure as follows: x := keyGen(); SLEEP(5 − t) → P ′ ⊳ (t := ∆t(key!x key?y) < 5) ⊲ STOP m 1 := encrypt(y, "message"); The timing condition of weak (t, ω I , ω H )-bisimulation specified in Definition 4 is now ensured, while the configuration condition is still violated. This will be addressed in next Section.

Flow Security Type System for CSP 4v
In order to make the low observation and cache accessing time of the executions be high input independent, the variables and cache lines are associated with security labels, VMs and hosts are assigned to categories, rules (semantic + typing) are required to ensure that: no information flows to lower level objects, no cache is shared among different VM instances, processes (c.f. instances) are not allowed to move from a lower order instance (c.f. host) to a higher one, and cache related operations in communications between processes are forced to be completed in certain time, and hence the cache flow policy is enforced.
For a process P (w.r.t. a component of G), we consider the type judgements have the form of: where the type (τ, ω I , ω H ) denotes the (environment) counter security levels of the communication channel/variables and and counter categories of VMs/hosts participated in the branch events being executed for the purpose of eliminating implicit flows from the guard. Ξ and Ξ ′ describe the type environment which hold before and after the execution of P . In general, notation: Ξ ⊢ (exp : τv t e , l : τc t l , l : αc i l , i : describes that under type environment Ξ, expression exp and (the address of) cache line l has type t e and t l respectively, l is allocated to VM instance i l , instance i is assigned to a category ω I , and host h is assigned to a category ω H . The type of an expression including boolean expression is defined by taking the least upper bound of the types of its free variables as standard: All memory, caches and channels written by a t-level expression becomes tagged as t-level. Let Vars P and CLines P denote a set of variables defined in and cache lines allocated to process P . Typing rules for processes with security configuration are presented in Table 3. Rule TStop for stopping a process P ensures the cache lines allocated to P to be flushed as empty with a label of system low ⊥ for future use. Rule for assignment TAssign ensures the type of variable x to be the least upper bound of the type of the assigned expression exp and the counter level τ . Rule TMove regarding moving a process from one instance to another enforces the type of each variable and cache line involved in process P to be the least upper bound of the type of itself and the counter level τ , and ensures its owner to be the VM identifier i ′ where the process is moving to, and ensures category of the moving-to-instance to be the least upper bound of that of itself and the moving-from-instance; rule TMove regarding moving an instance from one host h to another h ′ essentially moves all processes running upon the instance to h ′ such that each of which follows the rule of process moving. Rule for composition TSeq ensures the typing environment in terms of the sequential event in a compositional way. Rule for sending operator TSend ensures that the type of  Table 3. Typing rules for processes with security configuration.
the cache channel for sending expression w is to be the least upper bound of the type of w and the counter level, and rule for receiving operator TRecv ensures that the type of the receiving variable x is to be the least upper bound of the type of channel and the counter level. Rule for branch event TBranch specifies that the typing environment is required to be enforced in terms of the branch body with the counter level being the least upper bound of the current counter level and the type of the guard. Rule for loop operator TLoop calculates the least fixed point of the type environment transition function on the security lattice. Rule for parallel operator TPar ensures that the type of each information container (including process variables and cache lines) is to be the least upper bound after the execution of each parallel process. In overall, the derivation rule (τ, ω I , ω H ) ⊢ Ξ{P }Ξ ′ ensures that: variables and cache lines whose final types in Ξ ′ are less than τ must not be changed by P ; -the final value of a variable (or a cache line) say x whose final type is Ξ ′ (x) = t must not depend on the initial values of those variables (or cache lines) say z whose initial type Ξ(z) is greater than t. -processes (c.f. instances) belonging to a higher order category instances (c.f. host) must not move to an instance (c.f. a host) with a lower order category.
Theorem 1 (Monotonicity of the type environment transition function). Given L and P , for all τ , ω I , ω H and Ξ, the type environment transition function: Proof. The proof is obtained by induction on the semantic structure of the process. Particularly, for the case of loop, the sequences of . . form ascending chains with a least upper bound due to the finiteness of L, so rule TLoop calculates the least fixed point of T P, L on L.
Theorem 2 (Soundness of the flow security type system). The type system proposed in Table 3 is sound, i.e., Proof. Since τ ⊢ Ξ{P }Ξ ′ ensures that: for all variables and cache lines x, whenever Ξ ′ (x) ⊏ τ then there are no assignments to x in P , and thus i) is clearly satisfied; and for any variables y, such that Ξ(y) ⊐ Ξ ′ (x), the final value of x does not depend on the initial values of y, we can then prove for all t ∈ L, o ∈ Ω I , o ′ ∈ Ω H , configurations Γ and Γ ′ such that P, Γ ⇓ Γ ′ , whenever Γ 1 = Ξ,(τ,ωI ,ωH ) Γ 2 then Γ ′ 1 = Ξ,(τ,ωI ,ωH ) Γ ′ 2 , by induction on the structure of the derivation tree.
Theorem 3 (Flow secure of communications). Given a CSP 4v model A, for all P running upon any VM i of any host h in A, if (Ξ{P }Ξ ′ ) |= φ τ,ωI ,ωH , then A is weak cache flow secure with L = τ .
Proof. The proof includes two parts in terms of the definition of weak cache flow security policy given in Definition 5: channel of timing observable behaviours of victim process, and channel of observable low outputs influenced by high inputs. The first part is ensured by the semantics of communications specified in (1), which must be completed in certain time, and the second part is ensured by the soundness of the type system presented in Theorem 2.

Related Work
This paper relates to the topic of information flow analysis in virtualised computing systems from perspective of formal languages with a concern of cache timing attacks.
Cross-VM side-channel attacks in virtualised infrastructure allowed the attacker to extract information from a target VM and stole confidential information from the victims [24,32,33]. Over the last decade, there have been sustained efforts in exploring solutions to defend cache channel attacks in virtualised computing environment via the approaches of cache partition at either hardware-level [30,31,6,15] or system-level [21,26,14,34,17], and the approaches of cache randomisation via introducing randomization in cache uses through either new hardware design [29,30,31,18,16,23] or compiler-assistant design [7,16,4,22]. Wang and Lee [30] identified cache interference as the main cause of different types of cache side channel attacks. Security-aware cache designs were proposed to mitigate the cache interference issue: Partition-Locked cache (PLcache) eliminated cache interference via preventing cache sharing in a flexible way, and Random Permutation cache (RPcache) allowed cache sharing but randomised cache interference so that no information can be deduced. More recently, Liu et. al. [17] developed CATalyst to defend cache-based side channel attacks for the cloud computing system. Specifically, CATalyst used Cache Allocation Technology (CAT) on Intel processors to partition the last-level cache into secure and non-secure partitions. The secure partition was loaded with cache-pinned secure pages and was software-managed, while the non-secure partition can be freely used by any applications and kept hardware-managed. Security-sensitive code and data can be loaded and locked by users via mapping them to the cachepinned pages. Thus a hybrid hardware-software managed cache was constructed to protect the sensitive code and data. However, these efforts mostly require significant changes to the hardware, hypervisors, or operating systems, which make them impractical to be deployed in current cloud data centres. Formal treatment on flow security policies upon side-channel attack detection, leveraging program analysis techniques and relevant tools are still needed in order to improve the accuracy and applicability of leakage analysis and control in the virtualised infrastructure. In this paper, we address the flow security issue in virtualised computing environment from perspective of programming language and program analysis techniques.
On the other hand, there have been lasting investigations on flow property specification and enforcement via approaches of formal language and analysis. The conception of information flow specifies the security requirements of the system where no sensitive information should be released to the observer during its executions. Denning and Denning [5] first used program analysis to investigate if the information flow properties of a program satisfy a specified multi-level security policy. Goguen and Meseguer [8] formalised the notion of absence of information flow with the concept of non-interference. Ryan and Schneider [25] took a step towards the generalisation of a CSP formulation of non-interference to handle information flows through the concept of process equivalence. Security type systems [28,19,11,20,12,2,13] had been substantially used to formulate the analysis of secure information flow in programs. In addition to type-based treatments of secure information flow analysis for programs, Clark et. al presented a flow logic approach in [3], Amtoft and Banerjee proposed a Hoare-like logic for program dependence in [1]. Hammer and Snelting [9] presented an approach for information flow control in program analysis based on program dependence graphs (PDG). Based on [9], [27] extended the PDG-based flow analysis by incorporating refinement techniques via path conditions to improve the precision of the flow control. Such PDG-based information flow control is more precise but more expensive than type-based approaches. However, none of the above works has addressed the issue of flow analysis in virtualised computing systems regarding observations on both executions of communicating processes and affections of cache timing channels.

Conclusions
We have proposed a language-based approach for information leakage analysis and control in virtualised computing infrastructure with a concern of cache timing attacks. Specifically, we have introduced a distributed process algebra with processes able to capture flow security characters in a virtualised environment; we have described a cache flow policy for leakage analysis through communica-tion covert channels; and we have presented a type system of the language to enforce the flow policy. In our future work, we plan to derive concrete implementation of our approach and to extend the current model to define and enforce more practical security policies.