2
$\begingroup$

In some security proofs it is stated that "a protocol securely realizes an ideal functionality" while in some others "a protocol securely implements an ideal functionality".

  1. Is there a meaningful difference or it is just another verb to say a similar thing?
  2. Also, is there any difference between emulation and simulation in the context of MPC?

Update:

Example for question 1: Outsourced pattern matching, S. Faust, et al. see Definition 3 and compare with 5PM: secure pattern matching, J. Baron, et al. page 29 definition 5.

Example for question 2: wikipedia article on Universal composability:

Literally, the protocol may simulate the other protocol (without having access to the code). The notion of security is derived by implication. Assume a protocol P_1 is secure per definition. If another protocol P_2 emulates protocol P_1 such that no environment tells apart the emulation from the execution of the protocol, then the emulated protocol P_2 is as secure as protocol P_1.

$\endgroup$
  • 4
    $\begingroup$ No difference. Just terminology. $\endgroup$ – Yehuda Lindell Nov 9 '15 at 14:14
4
$\begingroup$

Realizes vs Implements
Given the context of the cited papers, they mean the same thing. That said, I would prefer realizes. Implements has a connotation of a source code implementation. There could be implementation flaws (buffer overflow, etc) that impact security. The protocol design is secure, but the implementation is not. That, to me, is the primary reason to prefer realizes over implements.

Simulate vs emulate
The difference in the wording on the Wiki stems from the difference between the two. I found this description of the general difference between the two to be good.

Emulation is the process of mimicking the outwardly observable behavior to match an existing target. The internal state of the emulation mechanism does not have to accurately reflect the internal state of the target which it is emulating.

Simulation, on the other hand, involves modeling the underlying state of the target. The end result of a good simulation is that the simulation model will emulate the target which it is simulating.

So, the wiki article says that "the protocol may simulate the other protocol", but it doesn't have to simulate it (in terms of modeling the underlying state of the target). All it really has to do is emulate, or mimick the outwardly observable behavior. So, internally, we may be simulating the protocol, or we may be doing something else, as long as as long as the outside observable behavior matches.

Note that in Universal Composability, there is a simulator $S$, that is not called a simulator because it simulates the real functionality, it is called a simulator because

We often call the adversary $S$ a simulator. This is due to the fact that in typical proofs of security the constructed $S$ operates by simulating an execution of $\mathcal{A}$.

$\endgroup$
  • $\begingroup$ Actually I want to know Simulate vs Emulate in the context of MPC. Professor Lindell said there is no difference in a comment. $\endgroup$ – MH Samadani Nov 9 '15 at 14:22
  • 1
    $\begingroup$ The quoted part is exactly what it is in the contxt of MPC. It is two different points of view of (mostly) the same thing. Internal vs external. $\endgroup$ – tylo Nov 9 '15 at 14:41
  • $\begingroup$ You can also say "X is realized by Y" if that is less awkward to you. Ultimately it just means "to make real, concrete". $\endgroup$ – Thomas Nov 9 '15 at 18:52

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.