gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r34535 - gnunet/src/scalarproduct


From: gnunet
Subject: [GNUnet-SVN] r34535 - gnunet/src/scalarproduct
Date: Thu, 11 Dec 2014 22:55:36 +0100

Author: grothoff
Date: 2014-12-11 22:55:36 +0100 (Thu, 11 Dec 2014)
New Revision: 34535

Modified:
   gnunet/src/scalarproduct/gnunet-service-scalarproduct_alice.c
   gnunet/src/scalarproduct/gnunet-service-scalarproduct_bob.c
   gnunet/src/scalarproduct/perf_scalarproduct.sh
   gnunet/src/scalarproduct/test_scalarproduct.conf
Log:
-fix bugs

Modified: gnunet/src/scalarproduct/gnunet-service-scalarproduct_alice.c
===================================================================
--- gnunet/src/scalarproduct/gnunet-service-scalarproduct_alice.c       
2014-12-11 19:01:29 UTC (rev 34534)
+++ gnunet/src/scalarproduct/gnunet-service-scalarproduct_alice.c       
2014-12-11 21:55:36 UTC (rev 34535)
@@ -861,7 +861,7 @@
  * Maximum number of elements we can put into a single cryptodata
  * message
  */
-#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - sizeof 
(struct AliceCryptodataMessage)) / sizeof (struct 
GNUNET_CRYPTO_PaillierCiphertext))
+#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - 
sizeof (struct AliceCryptodataMessage)) / sizeof (struct 
GNUNET_CRYPTO_PaillierCiphertext))
 
 
 /**
@@ -911,15 +911,16 @@
     msg->contained_element_count = htonl (todo_count);
     payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
     a = gcry_mpi_new (0);
-    for (i = off; i < todo_count; i++)
+    for (i = off; i < off + todo_count; i++)
     {
       gcry_mpi_add (a,
                     s->sorted_elements[i].value,
                     my_offset);
-      GNUNET_CRYPTO_paillier_encrypt (&my_pubkey,
-                                      a,
-                                      3,
-                                      &payload[i - off]);
+      GNUNET_assert (3 ==
+                     GNUNET_CRYPTO_paillier_encrypt (&my_pubkey,
+                                                     a,
+                                                     3,
+                                                     &payload[i - off]));
     }
     gcry_mpi_release (a);
     off += todo_count;
@@ -1321,6 +1322,7 @@
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Shutting down, initiating cleanup.\n");
+  // FIXME: we have to cut our connections to CADET first!
   if (NULL != my_cadet)
   {
     GNUNET_CADET_disconnect (my_cadet);

Modified: gnunet/src/scalarproduct/gnunet-service-scalarproduct_bob.c
===================================================================
--- gnunet/src/scalarproduct/gnunet-service-scalarproduct_bob.c 2014-12-11 
19:01:29 UTC (rev 34534)
+++ gnunet/src/scalarproduct/gnunet-service-scalarproduct_bob.c 2014-12-11 
21:55:36 UTC (rev 34535)
@@ -542,7 +542,7 @@
 /**
  * Maximum count of elements we can put into a multipart message
  */
-#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - sizeof 
(struct BobCryptodataMultipartMessage)) / sizeof (struct 
GNUNET_CRYPTO_PaillierCiphertext))
+#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - 
sizeof (struct BobCryptodataMultipartMessage)) / sizeof (struct 
GNUNET_CRYPTO_PaillierCiphertext))
 
 
 /**
@@ -615,8 +615,9 @@
   struct GNUNET_CRYPTO_PaillierCiphertext *payload;
   unsigned int i;
 
-  s->cadet_transmitted_element_count = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - 
sizeof (struct BobCryptodataMessage)) /
-    (sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * 2) - 2;
+  s->cadet_transmitted_element_count
+    = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof (struct 
BobCryptodataMessage))
+       / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
   if (s->cadet_transmitted_element_count > s->used_element_count)
     s->cadet_transmitted_element_count = s->used_element_count;
 
@@ -659,6 +660,7 @@
                   e);
   transmit_bobs_cryptodata_message_multipart (s);
 }
+#undef ELEMENT_CAPACITY
 
 
 /**
@@ -697,8 +699,9 @@
  *     S': $S' := E_A(sum r_i^2)$
  *
  * @param request the requesting session + bob's requesting peer
+ * @return #GNUNET_OK on success
  */
-static void
+static int
 compute_service_response (struct BobServiceSession *session)
 {
   uint32_t i;
@@ -751,16 +754,22 @@
     // E(S - r_pi - b_pi)
     gcry_mpi_sub (tmp, my_offset, rand[p[i]]);
     gcry_mpi_sub (tmp, tmp, b[p[i]].value);
-    GNUNET_CRYPTO_paillier_encrypt (&session->cadet->remote_pubkey,
-                                    tmp,
-                                    2,
-                                    &r[i]);
+    GNUNET_assert (2 ==
+                   GNUNET_CRYPTO_paillier_encrypt 
(&session->cadet->remote_pubkey,
+                                                   tmp,
+                                                   2,
+                                                   &r[i]));
 
     // E(S - r_pi - b_pi) * E(S + a_pi) ==  E(2*S + a - r - b)
-    GNUNET_CRYPTO_paillier_hom_add (&session->cadet->remote_pubkey,
-                                    &r[i],
-                                    &a[p[i]],
-                                    &r[i]);
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_paillier_hom_add (&session->cadet->remote_pubkey,
+                                        &r[i],
+                                        &a[p[i]],
+                                        &r[i]))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
   }
 
   // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
@@ -768,35 +777,43 @@
   {
     // E(S - r_qi)
     gcry_mpi_sub (tmp, my_offset, rand[q[i]]);
-    GNUNET_assert (2 == GNUNET_CRYPTO_paillier_encrypt 
(&session->cadet->remote_pubkey,
-                                                        tmp,
-                                                        2,
-                                                        &r_prime[i]));
+    GNUNET_assert (2 ==
+                   GNUNET_CRYPTO_paillier_encrypt 
(&session->cadet->remote_pubkey,
+                                                   tmp,
+                                                   2,
+                                                   &r_prime[i]));
 
     // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
-    GNUNET_assert (1 == GNUNET_CRYPTO_paillier_hom_add 
(&session->cadet->remote_pubkey,
-                                                        &r_prime[i],
-                                                        &a[q[i]],
-                                                        &r_prime[i]));
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_paillier_hom_add (&session->cadet->remote_pubkey,
+                                        &r_prime[i],
+                                        &a[q[i]],
+                                        &r_prime[i]))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
   }
   gcry_mpi_release (tmp);
 
   // Calculate S' =  E(SUM( r_i^2 ))
   tmp = compute_square_sum (rand, count);
-  GNUNET_CRYPTO_paillier_encrypt (&session->cadet->remote_pubkey,
-                                  tmp,
-                                  1,
-                                  &session->s_prime);
+  GNUNET_assert (1 ==
+                 GNUNET_CRYPTO_paillier_encrypt 
(&session->cadet->remote_pubkey,
+                                                 tmp,
+                                                 1,
+                                                 &session->s_prime));
   gcry_mpi_release (tmp);
 
   // Calculate S = E(SUM( (r_i + b_i)^2 ))
   for (i = 0; i < count; i++)
     gcry_mpi_add (rand[i], rand[i], b[i].value);
   tmp = compute_square_sum (rand, count);
-  GNUNET_CRYPTO_paillier_encrypt (&session->cadet->remote_pubkey,
-                                  tmp,
-                                  1,
-                                  &session->s);
+  GNUNET_assert (1 ==
+                 GNUNET_CRYPTO_paillier_encrypt 
(&session->cadet->remote_pubkey,
+                                                 tmp,
+                                                 1,
+                                                 &session->s));
   gcry_mpi_release (tmp);
 
   session->r = r;
@@ -810,8 +827,7 @@
   GNUNET_free (p);
   GNUNET_free (q);
   GNUNET_free (rand);
-
-  // copy the r[], r_prime[], S and Stick into a new message, 
prepare_service_response frees these
+  return GNUNET_OK;
 }
 
 
@@ -877,6 +893,8 @@
 static void
 transmit_cryptographic_reply (struct BobServiceSession *s)
 {
+  struct GNUNET_CADET_Channel *channel;
+
   /* TODO: code duplication with Alice! */
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received everything, building reply for Alice\n");
@@ -891,7 +909,14 @@
          s->used_element_count,
          sizeof (struct MpiElement),
          &element_cmp);
-  compute_service_response (s);
+  if (GNUNET_OK !=
+      compute_service_response (s))
+  {
+    channel = s->cadet->channel;
+    s->cadet->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+    return;
+  }
   transmit_bobs_cryptodata_message (s);
 }
 
@@ -1421,7 +1446,7 @@
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Shutting down, initiating cleanup.\n");
-  // FIXME: do we have to cut our connections to CADET first?
+  // FIXME: we have to cut our connections to CADET first!
   if (NULL != my_cadet)
   {
     GNUNET_CADET_disconnect (my_cadet);

Modified: gnunet/src/scalarproduct/perf_scalarproduct.sh
===================================================================
--- gnunet/src/scalarproduct/perf_scalarproduct.sh      2014-12-11 19:01:29 UTC 
(rev 34534)
+++ gnunet/src/scalarproduct/perf_scalarproduct.sh      2014-12-11 21:55:36 UTC 
(rev 34535)
@@ -2,13 +2,15 @@
 # Computes a simple scalar product, with configurable vector size.
 #
 # Some results:
-# SIZE   TIME(s)
+# SIZE   TIME-H(s)  TIME-O(s)
 #  25     10
 #  50     17
-# 100     32
+# 100     32          39
+# 200                 77
 #
+#
 # Configure benchmark size:
-SIZE=1000
+SIZE=400
 #
 # Construct input vectors:
 INPUTALICE="-k CCC -e '"
@@ -45,6 +47,8 @@
 echo "Running problem of size $SIZE"
 gnunet-scalarproduct $CFGBOB $INPUTBOB &
 time RESULT=`gnunet-scalarproduct $CFGALICE $INPUTALICE -p $PEERIDBOB`
+gnunet-statistics $CFGALICE -s core | grep "bytes encrypted"
+gnunet-statistics $CFGBOB -s core | grep "bytes encrypted"
 
 echo "Terminating testbed..."
 # terminate the testbed

Modified: gnunet/src/scalarproduct/test_scalarproduct.conf
===================================================================
--- gnunet/src/scalarproduct/test_scalarproduct.conf    2014-12-11 19:01:29 UTC 
(rev 34534)
+++ gnunet/src/scalarproduct/test_scalarproduct.conf    2014-12-11 21:55:36 UTC 
(rev 34535)
@@ -1,3 +1,5 @@
address@hidden@ ../../contrib/no_forcestart.conf
+
 [PATHS]
 GNUNET_TEST_HOME = /tmp/test-scalarproduct/
 




reply via email to

[Prev in Thread] Current Thread [Next in Thread]