Security of cloud computational protocols in UC Framework? The universal composability allows one to the analyze security of cryptographic protocols . But it does have some gaps when it comes to analyzing few protocols especially two party cases when there is no honest majority players 

Now when it comes to protocols designed for cloud computing, where few parties outsource computations to a service provider.  How do we prove the security of such protocols ? 

Trivial example is Alice encrypts all her data using FHE schemes and outsources to Sally . Sally should now compute any function on the encrypted data requested by the Alice.

Notice that this simple case is different from two party secure function evaluation. 

Now more complex protocols would be when Alice, Bob are two users who wants to execute some function on the shared data outsourced to Sally. So how do we prove security of  protocols designed for such functionality?
I think it is still possible to use UC in this case.

Recall the setup for the UC framework. We have an ideal world and a real world. There are parties $P_1,\dots,P_n$ in each world and an environment $\mathcal{Z}$ in each. In the real world we have the adversary $\mathcal{A}$ while in the ideal world, we have an ideal functionality $\mathcal{F}$ and a simulator $\mathcal{S}$. In the real world, the parties run some protocol $\pi$ while $\mathcal{F}$ should compute the same functionality as $\pi$ in the ideal world and be secure by definition (basically it is a trusted 3rd party). See the graphic below (taken from Martin Geisler's PhD thesis)



So, in your case, you have 3 parties. $P_1=\text{Alice},P_2=\text{Bob},P_3=\text{Sally}$. I'm not going to mess with specifying the protocol $\pi$. In the ideal world we can have a very simple setup. $P_1$ and $P_2$ submit their inputs (in plaintext over a private channel) to $\mathcal{F}$ and $P_3$ issues commands to $\mathcal{F}$ with what to do with those inputs (e.g., "compute the sum", etc).

In the real world $\mathcal{A}$ is basically $P_3$, so we assume that anything $P_3$ knows, $\mathcal{A}$ also knows. That information is then leaked to $\mathcal{Z}$. Then in the ideal world, you'll have to construct $\mathcal{S}$ in such a way that $\mathcal{Z}$ cannot distinguish between the two worlds. How exactly you do this will depend greatly on $\pi$.

As an example, let's say we are just computing the sum of the inputs using Paillier. In $\pi$, $P_1$ and $P_2$ might encrypt their inputs with the Paillier public key (who knows the private key is up to you, but it shouldn't be $P_3$) and send them to $P_3$. Then, if $P_3$ decides to, it will homomorphically sum the values and send the resulting ciphertext back to $P_1$ and $P_2$. To make it general, we'll just let $\mathcal{Z}$ provide $P_1$ and $P_2$ with their inputs and with $P_3$'s choice.

In the ideal world, $P_1$ and $P_2$ pass their inputs (from $\mathcal{Z}$) to $\mathcal{F}$. Then, if $P_3$ tells $\mathcal{F}$ to compute the sum, $\mathcal{F}$ does so. Furthermore, it will leak an encryption (using the paillier public key) of the result to $\mathcal{S}$ who passes that to $\mathcal{Z}$. You can also have $\mathcal{S}$ leak encryptions of the inputs to $\mathcal{Z}$ in a similar manner.

In both worlds, $\mathcal{Z}$ sees encrypted inputs and an encrypted output (if $P_3$ decides to allow the computation). Thus the two worlds are indistinguishable (assuming IND-CPA of the cipher) and the real world is as secure as the ideal world.