viff

changeset 1419:f264239b594d

viff: removed text made redundant by cf1d7d3eab0a
author Martin Geisler <mg@cs.au.dk>
date Mon, 14 Dec 2009 16:36:37 +0100
parents cbfa7ea6dae7
children f463223ea803
files viff/__init__.py
diffstat 1 files changed, 1 insertions(+), 103 deletions(-) [+]
line diff
     1.1 --- a/viff/__init__.py	Mon Dec 14 13:01:24 2009 +0100
     1.2 +++ b/viff/__init__.py	Mon Dec 14 16:36:37 2009 +0100
     1.3 @@ -1,4 +1,4 @@
     1.4 -# Copyright 2007, 2008 VIFF Development Team.
     1.5 +# Copyright 2007, 2008, 2009 VIFF Development Team.
     1.6  #
     1.7  # This file is part of VIFF, the Virtual Ideal Functionality Framework.
     1.8  #
     1.9 @@ -20,111 +20,6 @@
    1.10  
    1.11  VIFF is a Python framework for writing multi-party computations (MPC)
    1.12  in an easy, efficient, and secure way.
    1.13 -
    1.14 -Overview
    1.15 -========
    1.16 -
    1.17 -VIFF allows you to write a program which will interact with other
    1.18 -programs in order to execute a joint computation. This is called a
    1.19 -multi-party computation, MPC for short.
    1.20 -
    1.21 -The programs will implement what we call a virtual ideal functionality
    1.22 -(IF). The idea is that the behavior of the programs should be
    1.23 -indistinguishable from the behavior of programs interacting with a
    1.24 -so-called ideal functionality. An ideal functionality is a player that
    1.25 -cannot be corrupted, also known as a trusted third party (TTP).
    1.26 -
    1.27 -Interacting with an IF is easy: all players give their inputs to the
    1.28 -IF, which computes the results. The results are then distributed to
    1.29 -the correct players. The inputs and the results are sent over secure
    1.30 -channels, and since the IF cannot be corrupted, this ideal protocol
    1.31 -must be secure.
    1.32 -
    1.33 -In the real world there is no IF, but VIFF allows you to implement a
    1.34 -virtual ideal functionality. The behavior of a bunch of programs using
    1.35 -VIFF is indistinguishable from program running in the ideal world. It
    1.36 -is indistinguishable in the sense that everything that can happen in
    1.37 -the real world protocol could happen in the ideal world too. And since
    1.38 -no attacks can occur in the ideal world, no attacks can occur in the
    1.39 -real world as well. Such a multi-party computation (MPC) is called a
    1.40 -secure multi-party computation (SMPC).
    1.41 -
    1.42 -Security Assumptions
    1.43 ---------------------
    1.44 -
    1.45 -Please note that like all cryptographic systems, VIFF is only secure
    1.46 -as long as certain assumptions are fulfilled. These assumptions
    1.47 -include:
    1.48 -
    1.49 -  - The adversary can only corrupt up to a certain threshold of the
    1.50 -    total number of players. The threshold will normally be 1/2 of the
    1.51 -    players, so for three players, at most one player may be
    1.52 -    corrupted (there must be an honest majority).
    1.53 -
    1.54 -  - The adversary is computationally bounded. The protocols used by
    1.55 -    VIFF rely on certain computational hardness assumptions, and
    1.56 -    therefore only polynomial time adversaries are allowed.
    1.57 -
    1.58 -  - The adversary is passive. Being passive means that the adversary
    1.59 -    only monitors the network traffic, but still follows the protocol.
    1.60 -    We plan to add support for active (Byzantine) adversaries in a
    1.61 -    future version.
    1.62 -
    1.63 -The precise assumptions for each protocol will eventually be included
    1.64 -in the documentation for the corresponding method, but this has not
    1.65 -yet been done.
    1.66 -
    1.67 -Architecture
    1.68 -============
    1.69 -
    1.70 -VIFF consists of several modules. The L{passive} and L{active} modules
    1.71 -contain the L{PassiveRuntime} and L{ActiveRuntime} classes in which
    1.72 -the main functionality is implemented. The L{runtime} module contain
    1.73 -the L{Share} class and other infrastructure for the two runtime
    1.74 -classes. The L{field} module contains implementations of finite fields
    1.75 ---- these are the values inside the shares. Other modules provide
    1.76 -support functions.
    1.77 -
    1.78 -Layers
    1.79 -------
    1.80 -
    1.81 -The main functionality in VIFF is implemented in the L{PassiveRuntime}
    1.82 -class. This class offers methods to do addition, multiplication, etc.
    1.83 -These methods operate on L{Share} instances.
    1.84 -
    1.85 -Shares hold either L{field.GF} or L{GF256} elements and are created
    1.86 -from the C{shamir_share} or C{prss_share} Runtime methods. Shares
    1.87 -overload the standard arithmetic operators, so you can write C{a + b -
    1.88 -c * d} with four shares, and it will be translated correctly into the
    1.89 -appropriate method calls on the Runtime instance associated with the
    1.90 -shares.
    1.91 -
    1.92 -A field element contain the concrete value on which we do
    1.93 -calculations. This is just a normal Python (long) integer. The value
    1.94 -is wrapped in an object that will keep track of doing modulo
    1.95 -reductions as appropriate.
    1.96 -
    1.97 -So in a nutshell, VIFF has these layers:
    1.98 -
    1.99 -  - Top-level layer for application programs: There you manipulate
   1.100 -    Python integers or L{Share} instances.
   1.101 -
   1.102 -  - Runtime layer: The runtime deals with Python integers or shares.
   1.103 -
   1.104 -  - Field elements: Deals with arithmetic over Python integers, but
   1.105 -    with modulo reductions as needed.
   1.106 -
   1.107 -
   1.108 -Getting into VIFF
   1.109 -=================
   1.110 -
   1.111 -As explained above, the main functionality in VIFF is the
   1.112 -L{PassiveRuntime} class, so please start there. Also, be sure to
   1.113 -checkout the example applications distributed in the C{apps}
   1.114 -directory.
   1.115 -
   1.116 -@authors: U{VIFF Development Team <mailto:viff-devel@viff.dk>}
   1.117 -@see: U{http://viff.dk/}
   1.118  """
   1.119  
   1.120  __version__ = '0.7.1'