When working with State Separable Proofs, it’s often easier to frame every game as distinguishing between the “real world” and the “ideal world”. This allows keeping the framing consistent throughout the composition of different games / packages.

For example, the security of a PRF is defined in this real ideal paradigm, by distinguishing between the case of actually calling the PRF with a key, and the case of a genuine random function.

If you then use this PRF to make an encryption scheme, it’s useful to also define security in terms of distinguishing between encrypting messages, and encrypting random ciphertexts, which helps the proofs go more smoothly when trying to reduce the security of the larger encryption scheme to the security of the smaller PRF.

Contrast this with the other common notion of encryption security, in which the adversary sends two messages each round, and has to figure out whether the challenger is consistently encrypting the first or the second message.

This begs the question: can you reduce the real-or-random notion of encryption to the left-or-right notion of encryption? Yes.

Background

For left-or-right, we have the following pair of games:

and for real-or-random, we have:

Note:

For full generality, you’d have a function which lets you sample a random message of the same length as another message, which lets you accomodate cases where the messages aren’t just simple bit-strings.

Note that because the oracles are the same in both cases, I’ll omit them in the reductions for simplicity.

In other words, for every adversary against with advantage , there exists an adversary against with advantage as well.

To show this, we provide a shim which provides the interface for over :

Then, we clearly have , in the sense of providing identical distributions. Thus , and is the adversary breaking .

The Other Direction

In the other direction, the idea is more subtle. We can’t directly translate an oracle encrypting either our message or a random message into one encrypting one of two messages.

The idea of the reduction in standard game notation is to choose the random bit for the message ourselves, inside of the shim. Then, if the adversary is able to accurately detect the bit, that tells us that we’re in the case where we’re not seeing random ciphertexts from the oracle.

There’s actually a general lesson to be learned here.

Let’s say you have two bit-indexed games, and .

If we look at:

Then we can replace with a concrete game , where the bit is flipped on initialization. Ditto with .

From a technical point of view, includes a special function to read this bit, called . Then, given an adversary for , whose interface doesn’t include , of course, we have an adversary which runs , and then checks if that bit is equal to , returning if that’s the case.

The question is about the advantage:

By definition, we have:

Letting , we can expand this to get:

Letting denote a similar quantity, we have:

which we can reduce to:

Using the reverse triangle inequality, we can write this as:

Or, in terms of advantages, we have:

Which is actually a useful result. We can use an adversary which can break the inner part, and use that to get an adversary breaking .

A similar reasoning shows that:

Let’s summarize the main result. Given an adversary playing against , there exists an adversary such that:

If we let , then we can create a shim such that , as follows:

It should be clear that provides an equivalent game as . Note also that , since the bit has no impact, since the ciphertext is always random.

We can now apply the result we derived in the previous section. Given an adversary playing against , there exists an adversary playing against such that:

The last part is , since the two games are equivalent.

And that implies the reduction.