gmane.comp.cryptography.viff.patches

[Fwd: [PATCH 1 of 1] Added computation-id option]

Marcel Keller — 2010-08-04T12:28:21

-------- Original Message --------
Subject: [PATCH 1 of 1] Added computation-id option
Date: Wed, 04 Aug 2010 12:17:43 -0000
From: Thomas P Jakobsen <tpj< at >cs.au.dk>
To: mkeller< at >cs.au.dk
CC: ttoft< at >cs.au.dk
References: <patchbomb.1280924262< at >dhcp-11-67-32.daimi.au.dk>

# HG changeset patch
# User Tomas Toft <ttoft< at >cs.au.dk>
# Date 1280227043 -7200
# Node ID 7c45463151f482ff75bbd877dad3509e8f9cb3c9
# Parent  e7b2fe7eb75319e2f60cc292b0d68fe568d394ab
Added computation-id option.

This changeset adds a command line option to VIFF allowing users to
specify a computation id.

Prior to this changeset, any computation involving pseudo-random
secret sharing (which for the time being boils down to computations
done with the PassiveRuntime) could only be run one time using the
same set of VIFF player configuration files. If more than one
computation was executed with the same set of configuration files, the
security of the system would be broken.

With this changeset, multiple computations can be run securely with
the sa

[PATCH 1 of 1] Added command line option for playerhost and port

Thomas P Jakobsen — 2010-04-13T18:15:23

# HG changeset patch
# User Thomas P Jakobsen <tpj< at >cs.au.dk>
# Date 1271181869 -7200
# Node ID 4a6c97b250725bb5a2bdf219ae00aa8e85b0d083
# Parent  6d838b2d24a22835782d71704c9ab5c7f22eac06
Added command line option for player host and port.

Sometimes it is more convenient to specify host and port numbers of
the players as command line arguments when running VIFF itself, rather
than by editing the configuration files.

This revision enables users to override host and port numbers
specified in the configuration files by command line arguments.

diff -r 6d838b2d24a2 -r 4a6c97b25072 viff/runtime.py
--- a/viff/runtime.pyTue Mar 30 11:34:39 2010 +0200
+++ b/viff/runtime.pyTue Apr 13 20:04:29 2010 +0200
< at >< at > -530,6 +530,12 < at >< at >
         group.add_option("--no-socket-retry", action="store_true",
                          default=False, help="Fail rather than keep retrying "
                          "to connect if port is already in use.")
+        group.add_option("--host", metavar="HOST:PORT", action="append",
+

[PATCH 0 of 1] Command line arguments for host andport.

Thomas P Jakobsen — 2010-04-13T18:15:22

Here's a patch that allows users to specify player host and port
numbers via the command line.

If theres no objections, I'll push this change into VIFF in a couple
of days.

Regards,
Thomas

Re: [PATCH] Added option to avoid retrying toconnect if socket isalready in use

Martin Geisler — 2010-01-20T11:26:57


Nice, please put it in yourself! :-)

[PATCH] Added option to avoid retrying to connect ifsocket isalready in use

Thomas P Jakobsen — 2010-01-20T07:56:34

# HG changeset patch
# User Thomas P Jakobsen <tpj< at >cs.au.dk>
# Date 1263974081 -3600
# Node ID 2324d01c74e2c35b5bb6cb4d7bda1304a376b066
# Parent  efa1983063d62a8115949a7e63d5ad4e5a23a791
Added option to avoid retrying to connect if socket is already in use.

In some situations it turns out to be more convenient to have VIFF
throw an exception rather than keep retrying to connect to a socket
with exponentially increasing delays. This is now possible using the
new command line parameter --no-socket-retry.

diff -r efa1983063d6 -r 2324d01c74e2 viff/runtime.py
--- a/viff/runtime.pyThu Jan 14 11:36:13 2010 +0100
+++ b/viff/runtime.pyWed Jan 20 08:54:41 2010 +0100
< at >< at > -525,6 +525,9 < at >< at >
                          help="Collect and print profiling information.")
         group.add_option("--track-memory", action="store_true",
                          help="Track memory usage over time.")
+        group.add_option("--no-socket-retry", action="store_true",
+                         default=False, help="Fail rather tha

Re: [PATCH] Added option to avoid retrying toconnect if socket is already in use

Thomas P Jakobsen — 2010-01-20T07:56:15

You're right. I'll send a modified patch soon.

Regards,
Thomas

Re: [PATCH] Added option to avoid retrying toconnect if socket isalready in use

Martin Geisler — 2010-01-19T23:11:52

_______________________________________________
viff-patches mailing list
viff-patches< at >viff.dk
http://lists.viff.dk/listinfo.cgi/viff-patches-viff.dk

[PATCH] Added option to avoid retrying to connect ifsocket isalready in use

Thomas P Jakobsen — 2010-01-19T22:18:59

# HG changeset patch
# User Thomas P Jakobsen <tpj< at >cs.au.dk>
# Date 1263939336 -3600
# Node ID 0b1e6cf3f57efe5a3b320897da636a6e2ebb2bdf
# Parent  efa1983063d62a8115949a7e63d5ad4e5a23a791
Added option to avoid retrying to connect if socket is already in use.

In some situations it turns out to be more convenient to have VIFF
throw an exception rather than keep retrying to connect to a socket
with exponentially increasing delays. This is now possible using the
new command line parameter --no-socket-retry.

diff -r efa1983063d6 -r 0b1e6cf3f57e viff/runtime.py
--- a/viff/runtime.pyThu Jan 14 11:36:13 2010 +0100
+++ b/viff/runtime.pyTue Jan 19 23:15:36 2010 +0100
< at >< at > -525,6 +525,10 < at >< at >
                          help="Collect and print profiling information.")
         group.add_option("--track-memory", action="store_true",
                          help="Track memory usage over time.")
+        group.add_option("--no-socket-retry", action="store_false",
+                         dest="socket_retry", default=True,

[PATCH 16 of 20] importeret rettelsetriple_combiner.patch

Janus Dam Nielsen — 2009-10-06T08:10:06

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID abe7f8ef29b1620b69666ff34bae3e8cdb469f8a
# Parent  04d228359cee302716040a5eebee38c46980a1b3
importeret rettelse triple_combiner.patch

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -55,6 +55,9 < at >< at >
     """
 
     def __init__(self, runtime, field, value=None, rho=None, commitment=None):
+        self.share = value
+        self.rho = rho
+        self.commitment = commitment
         Share.__init__(self, runtime, field, (value, rho, commitment))
 
 
< at >< at > -81,6 +84,9 < at >< at >
         """Initialize runtime."""
         Runtime.__init__(self, player, threshold, options)
         self.threshold = self.num_players - 1
+        self.s = 1
+        self.d = 0
+        self.s_lambda = 1
 
     def compute_delta(self, d):
         def product(j):
< at >< at > -1005,6 +1011,293 < at >< at >
 
         return result
 
+    def random_triple(self, field):
+        """Generate a list of triples

[PATCH 20 of 20] importeret rettelseautopreprocessing.patch

Janus Dam Nielsen — 2009-10-06T08:10:10

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID dd15e514cbb0a59f8cf06caa55064cccde3f9b41
# Parent  2dabe8c91e557603cbfeb84d39f892f6bf4e773f
importeret rettelse autopreprocessing.patch

diff --git a/apps/benchmark.py b/apps/benchmark.py
--- a/apps/benchmark.py
+++ b/apps/benchmark.py
< at >< at > -63,6 +63,7 < at >< at >
 import viff.reactor
 viff.reactor.install()
 from twisted.internet import reactor
+from twisted.internet.defer import Deferred
 
 from viff.field import GF, GF256, FakeGF
 from viff.runtime import Runtime, create_runtime, gather_shares, \
< at >< at > -87,12 +88,13 < at >< at >
     print "Started", what
 
 
-def record_stop(_, what):
+def record_stop(x, what):
     stop = time.time()
     print
     print "Total time used: %.3f sec" % (stop-start)
     print "Time per %s operation: %.0f ms" % (what, 1000*(stop-start) / count)
     print "*" * 6
+    return x
 
 operations = {"mul": (operator.mul,[]),
               "compToft05": (operator.ge, [ComparisonToft05Mixin]),
< at >

[PATCH 14 of 20] Implementation of the TripleGenprotocol

Janus Dam Nielsen — 2009-10-06T08:10:04

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID db2d970885f44d2cf18608c81f8422e87d97af8c
# Parent  86e0c7d54f2220bf03da45cf4269c88a7e6b777c
Implementation of the TripleGen protocol.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -19,8 +19,9 < at >< at >
 
 from viff.runtime import Runtime, Share, ShareList, gather_shares
 from viff.util import rand
-from viff.constants import TEXT
+from viff.constants import TEXT, PAILLIER
 from viff.field import FieldElement
+from viff.paillier import encrypt_r, decrypt
 
 from hash_broadcast import HashBroadcastMixin
 
< at >< at > -771,6 +772,200 < at >< at >
 
         return result
 
+    def triple_gen(self, field):
+        """Generate a triple ``a, b, c`` s.t. ``c = a * b``.
+
+        1) Every party ``P_i`` chooses random values ``a_i, r_i in Z_p X (Z_p)^2``,
+        compute ``alpha_i = Enc_eki(a_i)`` and ``Ai = Com_ck(a_i, r_i)``, and
+        broadcast them.
+
+        2) Every party `

[PATCH 12 of 20] Implementation of the basicmultiplication command

Janus Dam Nielsen — 2009-10-06T08:10:02

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID eb0443115206dc4a50bfea300c5582613d26326a
# Parent  a62e12c9947a9499dd293e2dce91992950505fee
Implementation of the basic multiplication command.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -459,6 +459,22 < at >< at >
              return results[0]
         return results       
 
+    def mul(self, share_x, share_y):
+        """Multiplication of shares.
+
+        Communication cost: ???.
+        """
+        # TODO: Communication cost?
+        assert isinstance(share_x, Share) or isinstance(share_y, Share), \
+            "At least one of share_x and share_y must be a Share."
+
+        self.program_counter[-1] += 1
+
+        field = getattr(share_x, "field", getattr(share_y, "field", None))
+
+        a, b, c = self._get_triple(field)
+        return self._basic_multiplication(share_x, share_y, a, b, c)
+
     def _additive_constant(self, zero, field_elem

[PATCH 17 of 20] Replace the current implementationof _get_triplewith a call to random triple

Janus Dam Nielsen — 2009-10-06T08:10:07

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID 2704f20bab087cc127acb0961acba98768a0123c
# Parent  abe7f8ef29b1620b69666ff34bae3e8cdb469f8a
Replace the current implementation of _get_triple with a call to random triple.

Implement the preprocessing interface.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -495,8 +495,17 < at >< at >
 
         field = getattr(share_x, "field", getattr(share_y, "field", None))
 
-        a, b, c = self._get_triple(field)
-        return self._basic_multiplication(share_x, share_y, a, b, c)
+        def finish_mul((a, b, c)):
+            return self._basic_multiplication(share_x, share_y, a, b, c)
+
+        # This will be the result, a Share object.
+        result = Share(self, share_x.field)
+        # This is the Deferred we will do processing on.
+        triple = self._get_triple(field)
+        triple = self.schedule_complex_callback(triple, finish_mul)
+        # We add

[PATCH 05 of 20] Boilerplate code for theimplementation of theOrlandi runtime

Janus Dam Nielsen — 2009-10-06T08:09:55

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID 7fe8f5835b61c495be6eb807cae043f6aa1fd908
# Parent  53d198cdf14cb85d81d6e6cf1ec75a16773dfbec
Boilerplate code for the implementation of the Orlandi runtime.

diff --git a/viff/orlandi.py b/viff/orlandi.py
new file mode 100644
--- /dev/null
+++ b/viff/orlandi.py
< at >< at > -0,0 +1,69 < at >< at >
+# Copyright 2009 VIFF Development Team.
+#
+# This file is part of VIFF, the Virtual Ideal Functionality Framework.
+#
+# VIFF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License (LGPL) as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# VIFF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+# Public License for more details.
+#
+# You s

[PATCH 06 of 20] Implemented secret sharing command

Janus Dam Nielsen — 2009-10-06T08:09:56

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID 42d95e56edf626b2a2c8535e5bfbe856a1e82a3b
# Parent  7fe8f5835b61c495be6eb807cae043f6aa1fd908
Implemented secret sharing command.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -15,8 +15,18 < at >< at >
 # You should have received a copy of the GNU Lesser General Public
 # License along with VIFF. If not, see <http://www.gnu.org/licenses/>.
 
+from twisted.internet.defer import Deferred
+
 from viff.runtime import Runtime, Share, ShareList, gather_shares
 from viff.util import rand
+from viff.constants import TEXT
+
+import commitment
+commitment.set_reference_string(23434347834783478783478L, 489237823478234783478020L)
+
+# import logging
+# LOG_FILENAME = 'logging_example.out'
+# logging.basicConfig(filename=LOG_FILENAME,level=logging.DEBUG,)
 
 class OrlandiException(Exception):
     pass
< at >< at > -67,3 +77,115 < at >< at >
         """Initialize runtime."""
         Runtime.__in

[PATCH 11 of 20] Implementation of input and shiftcommands

Janus Dam Nielsen — 2009-10-06T08:10:01

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID a62e12c9947a9499dd293e2dce91992950505fee
# Parent  5636b02c6beffac287fc05f62b87b3b03c01e116
Implementation of input and shift commands.

diff --git a/viff/hash_broadcast.py b/viff/hash_broadcast.py
--- a/viff/hash_broadcast.py
+++ b/viff/hash_broadcast.py
< at >< at > -96,7 +96,8 < at >< at >
             self._expect_data_with_pc(unique_pc, peer_id, HASH, d_hash)
             d_signal = Deferred().addCallbacks(signal_received, 
                                                self.error_handler, 
-                                               callbackArgs=(peer_id, message, len(receivers), g_hashes, signals))
+                                               callbackArgs=(peer_id, message, len(receivers), 
+                                                             g_hashes, signals))
             self._expect_data_with_pc(unique_pc, peer_id, SIGNAL, d_signal)
 
         # Set up receiving of the message.
diff --git a/v

[PATCH 02 of 20] Constants used in communication isrefactored to anew file

Janus Dam Nielsen — 2009-10-06T08:09:52

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816276 -7200
# Node ID 8a5eb65501118b57550a57504450ea6ae406d077
# Parent  c43b0e520aba3d9c7de29e494e0ff16d0f66cd37
Constants used in communication is refactored to a new file.

diff --git a/viff/active.py b/viff/active.py
--- a/viff/active.py
+++ b/viff/active.py
< at >< at > -28,7 +28,7 < at >< at >
 from viff.matrix import Matrix, hyper
 from viff.passive import PassiveRuntime
 from viff.runtime import Share, preprocess, gather_shares
-from viff.runtime import ECHO, READY, SEND
+from viff.constants import ECHO, READY, SEND
 
 
 class BrachaBroadcastMixin:
diff --git a/viff/constants.py b/viff/constants.py
new file mode 100644
--- /dev/null
+++ b/viff/constants.py
< at >< at > -0,0 +1,27 < at >< at >
+# -*- coding: utf-8 -*-
+#
+# Copyright 2009 VIFF Development Team.
+#
+# This file is part of VIFF, the Virtual Ideal Functionality Framework.
+#
+# VIFF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public

[PATCH 13 of 20] Implementation of the leak tolerantmultiplicationcommand

Janus Dam Nielsen — 2009-10-06T08:10:03

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID 86e0c7d54f2220bf03da45cf4269c88a7e6b777c
# Parent  eb0443115206dc4a50bfea300c5582613d26326a
Implementation of the leak tolerant multiplication command.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -81,6 +81,21 < at >< at >
         Runtime.__init__(self, player, threshold, options)
         self.threshold = self.num_players - 1
 
+    def compute_delta(self, d):
+        def product(j):
+            pt = 1
+            pn = 1
+            for k in xrange(1, 2 * d + 2):
+                if k != j:
+                    pt *= k
+                    pn *= k - j
+            return pt // pn
+
+        delta = []
+        for j in xrange(1, 2 * d + 2):
+            delta.append(product(j))
+        return delta
+
     def output(self, share, receivers=None, threshold=None):
         return self.open(share, receivers, threshold)
 
< at >< at > -243,8 +258,9 < at >< at >
             if Cx

[PATCH 10 of 20] Implementation of subtractioncommand

Janus Dam Nielsen — 2009-10-06T08:10:00

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816324 -7200
# Node ID 5636b02c6beffac287fc05f62b87b3b03c01e116
# Parent  94086392cb3c34db1672660c9711cbd4941c991f
Implementation of subtraction command.

diff --git a/viff/orlandi.py b/viff/orlandi.py
--- a/viff/orlandi.py
+++ b/viff/orlandi.py
< at >< at > -350,6 +350,39 < at >< at >
         result.addCallbacks(compute_sums, self.error_handler)
         return result
 
+    def sub(self, share_a, share_b):
+        """Subtraction of shares.
+
+        Communication cost: none.
+
+        Each party ``P_i`` computes:
+        ``[z]_i = [x]_i - [y]_i
+                = (x_i - y_i mod p, rho_x,i - rho_y,i mod p, C_x * C_y)``.
+
+        """
+        def is_share(s, field):
+            if not isinstance(s, Share):
+                if not isinstance(s, FieldElement):
+                    s = field(s)
+                (v, rhov, Cv) = self._additive_constant(field(0), s)
+                return OrlandiShare(self, field, v, rhov, Cv)
+

[PATCH 01 of 20] It is now possible to send data toyour self

Janus Dam Nielsen — 2009-10-06T08:09:51

# HG changeset patch
# User Janus Dam Nielsen <janus.nielsen< at >alexandra.dk>
# Date 1254816260 -7200
# Node ID c43b0e520aba3d9c7de29e494e0ff16d0f66cd37
# Parent  80125f56beaa186cda5d520c6f4b04da598e71bb
It is now possible to send data to your self.

The sendData and _expect_data primitives now accepts and transmits data send from a player to himself.

diff --git a/viff/runtime.py b/viff/runtime.py
--- a/viff/runtime.py
+++ b/viff/runtime.py
< at >< at > -382,6 +382,65 < at >< at >
         """Disconnect this protocol instance."""
         self.transport.loseConnection()
 
+class SelfShareExchanger(ShareExchanger):
+
+    def __init__(self, id, factory):
+        ShareExchanger.__init__(self)
+        self.peer_id = id
+        self.factory = factory
+
+    def stringReceived(self, program_counter, data_type, data):
+        """Called when a share is received.
+
+        The string received is unpacked into the program counter, and
+        a data part. The data is passed the appropriate Deferred in
+        :class:`self.incoming_

[PATCH 00 of 20] Implementation of the Orlandiruntime

Janus Dam Nielsen — 2009-10-06T08:09:50

Hi friends of VIFF,

This pathcbomb contains three contributions

1) I have made it possible for a player to send and expect data from him self. This simplifies the implementation of the broadcast protocol I have implemented for the Orlandi runtime

2) An implementation of the Orlandi runtime. I have decided not to include the code for the commitment scheme yet, since it uses propriatary code

3) A refactoring and improvement of the benchmark.py application


Please review the code.

--
Janus