Archive for the ‘Computing’ Category.

VIFF 0.2

Version 0.2 of my little pet project has been released! Changes since version 0.1.1 include:

Implemented overloaded arithmetic operators, so w = x + y * z now adds and multiplies the three shares as expected. Updated API documentation. Released using a Distutils setup.py script.

Get it at http://viff.dk/

In case you haven’t noticed: VIFF 0.1 is released

In my last post I asked you what name you preferred for my cryptographic runtime, and the winner is VIFF, which stands for Virtual Ideal Functionality Framework. Now I just need someone to make a logo with a cute little dog that says “Viff!” :-)

I packaged things up in a 0.1 release — VIFF is now online at http://viff.dk/ with the Mercurial repository at http://hg.viff.dk/viff/. If you are interested in the development of VIFF, then consider subscribing to new releases on Freshmeat. There will be a mailinglist up as soon as Gmane approves my application, stay tuned!

Vote for your favorite name

Some people complained that my last post contained too much text… I’ll make this shorter :-)

A week ago I asked you to help me find a name for a project I am working on. The project is a library of tools for writing secure multi-party computations in Python, and thus I have been calling it PySMPC until now. But since the project might one day be rewritten in another language, I would prefer to have another name.

Tord, Dan and Chris suggested new names, and including the ones I had come up with myself, we now have (in alphabetical order):

  • AMPC: Asynchronous Multi-Party Computation, 1 vote
  • AntiTrust
  • DTTP: Distributed Trusted Third Party, 1 vote
  • Jokke: no idea what that would mean, but Rune votes for it. 1 vote
  • NoTrent
  • NoTTP: No Trusted Third Party
  • NoTrust
  • PEBLE: Paranoid Economy Benchmarking Liability Elimination
  • SMPC: Secure Multi-Party Computation, 2 votes
  • smpacman: secure multi-party comp. manager, 1 vote
  • Trent
  • VIFF: Virtual Ideal Functionality Framework, 3 votes (give or take an ∞ or two…)

Please vote for your favorite name (multiple votes are okay) by leaving a comment.

Please help me choose a name for my project

I have been busy with a new project this summer, a project that will be part of my PhD in cryptographic protocols. It is working well, but I am not satisfied with the name I have come up with so far.

It is a library which enables you to write multi-party computations (MPC) in an easy way. A secure MPC protocol is a protocol between a number of players who seek to execute some joint computation, but done in a way in which they reveal nothing about their inputs. If the computation is the evaluation of a function f, then imagine each player Pi holding an input xi. When the protocol is finished, all players must know y = f(x1, x2, …, xn), but nothing more.

As an example where MPC is helpful, consider a bunch of companies that want to know how they compare to each other. So they want to compute their average profit, but are of course unwilling to share the private information about their expenses and incomes. This is the problem of benchmarking and traditionally this has been solved by having the companies reveal their sensitive information to a mutually trusted third-party. This could be a consulting company which has been paid so much money by the benchmarking participants that they can trust the consulting company not to cheat (the companies have essentially bribed the consulting company to be honest).

Paying a third-party so much money that he or she has no incentive to collude with a player is of course an expensive option. A secure multi-party computation can do the same, but without a trusted third-party. The protocol is designed in such a way that it acts as if there was a trusted third-party, a so-called ideal functionality present. An ideal functionality (IF) should be thought of as a computer which cannot be hacked and which faithfully carries out the program put into it. The players can therefore trust this computer and should simply reveal their private inputs to it.

In real life there is not such computer, but the MPC protocol creates a situation that look exactly as if there had been. This is the definition of security: the real protocol must look exactly as a protocol done in an ideal world. Because no attacks can occur in the ideal world (the IF cannot be attacked by definition) then we conclude that no attacks can occur in the real world as well. And so the protocol is called secure.

My library is written in Python and program written using it looks like this:

import sys
from X.field import GF
from X.config import load_config
from X.runtime import Runtime
from X.util import dprint

Z31 = GF(31)
my_id, conf = load_config(sys.argv[1])
my_input = Z31(int(sys.argv[2]))

rt = Runtime(conf, my_id, 1)
x, y, z = rt.shamir_share(my_input)
result = rt.open(rt.mul(rt.add(x, y), z))

dprint(”Result: %s”, result)
rt.wait_for(result)

This program starts by including some stuff from X, which stands for the package name of my library. It is this X that I want to see replaced by something else. The program then defines a field for the computation, loads the configuration and input. A Runtime is then created. The Runtime is used for all computations, it has methods for addition, multiplication, comparison and so on. In this example we compute (x+y)*z. The result is opened, printed and finally we ask the runtime to wait for the result.

The last point where we wait for a result is necessary since my library is asynchronous. The wait_for method goes into an event loop and only returns when the variables given have received a value. I use Twisted for the asynchronous infrastructure and it has worked extremely well.

So, if you’re with me so far, then you should have at least a rudimentary knowledge about MPC and what it is good for. I have already some name suggestions and I hope to get some feedback on them (listed in no particular order):

  • NoTTP, short for No Trusted Third-Party. This is what MPC does: it removes the trusted third-party. But does it look good if you write from nottp.field import GF256? Also, the name almost sounds like NoTCP which could be some weird project that loves UDP :-)

  • PySMPC, short for Python Secure Multi-Party Computation. The library is written in Python and does SMPC. One might drop the “S” and go with PyMPC since nobody wants to deal with in-secure MPC anyway :-) I don’t like that the name ties the library to Python since I might want to rewrite it in another language in the future.

  • Trent or NoTrent. Accourding to Wikipedia, Trent is sometimes used as the name of the trusted arbitrator in cryptographic protocols (like Alice and Bob is used instead of A and B). So this library could be said to give you a virtual “Trent” and help you get rid of a real one. I don’t like the word “Trent” since I don’t think it is that widely used.

  • VIFF, short for Virtual Ideal Functionality Framework. The library helps you create protocols that look exactly as if there has been an IF present. Therefore I think it can be said to create a virtual ideal functionality. Accourding to Google, VIFF mostly stands forVancouver International Film Festival“.

  • AMPC, short for Asynchronous Multi-Party Computation. This emphasizes the asynchronous nature of the library. I think it is somewhat difficult to pronounce “AMPC”.

Any other suggestions? Which name do you like the most? Please vote by leaving a comment! (Those of you who already know the name I have used so far are kindly asked not to reveal it — I want to collect some opinious first.)

By the way: instead of the abbreviations, I would prefer a name like “Twisted” or “Python” which can be pronounced and which people know how to spell and capitalize. There is another project in this area called FairPlay and I think this is a very good name: easy to remember, it can be abbreviated to just FP, and it actually says a bit about the project. So if you could suggest something along the lines of that it would be great! :-)

Live from TCC07

The last coffee break of the day has just finished and the talks are about to resume with a special event about the assumptions for cryptography. I’m in Amsterdam at the Theory of Cryptography Conference 2007 and have been listening to talks all day. Some were interesting and some were boring, but I guess that was to be expected.

What was not to be expected was the food: We got buns with different kinds of fillings (cheese, ham, raisins, etc.) and a glass of milk. There were also some deep-fried cheese.

In the coffee breaks they server, well…, coffee and tea with biscuits — I had a glass of water with my two biscuits :-/ Not so exciting, I hope the food will be better tomorrow.

Bye for now, I might write more tomorrow!