src/scalarproduct/gnunet-service-scalarproduct.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * @file scalarproduct/gnunet-service-scalarproduct.c
  23  * @brief scalarproduct service implementation
  24  * @author Christian M. Fuchs
  25  */
  26 #include <limits.h>
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_core_service.h"
  30 #include "gnunet_mesh_service.h"
  31 #include "gnunet_applications.h"
  32 #include "gnunet_protocols.h"
  33 #include "gnunet_scalarproduct_service.h"
  34 #include "scalarproduct.h"
  35
  36 #define LOG(kind,...) GNUNET_log_from (kind, "scalarproduct", __VA_ARGS__)
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39 //                     Service Structure Definitions
  40 ///////////////////////////////////////////////////////////////////////////////
  41
  42 /**
  43  * state a session can be in
  44  */
  45 enum SessionState
  46 {
  47     WAITING_FOR_BOBS_CONNECT,
  48     MESSAGE_FROM_RESPONDING_CLIENT_RECEIVED,
  49     WAITING_FOR_RESPONSE_FROM_SERVICE,
  50     REQUEST_FROM_SERVICE_RECEIVED,
  51     FINALIZED
  52 };
  53
  54 /**
  55  * role a peer in a session can assume
  56  */
  57 enum PeerRole
  58 {
  59     ALICE,
  60     BOB
  61 };
  62
  63
  64 /**
  65  * A scalarproduct session which tracks:
  66  *
  67  * a request form the client to our final response.
  68  * or
  69  * a request from a service to us(service).
  70  */
  71 struct ServiceSession
  72 {
  73     /**
  74      * the role this peer has
  75      */
  76     enum PeerRole role;
  77
  78     /**
  79      * session information is kept in a DLL
  80      */
  81     struct ServiceSession *next;
  82
  83     /**
  84      * session information is kept in a DLL
  85      */
  86     struct ServiceSession *prev;
  87
  88     /**
  89      * (hopefully) unique transaction ID
  90      */
  91     struct GNUNET_HashCode key;
  92
  93     /**
  94      * state of the session
  95      */
  96     enum SessionState state;
  97
  98     /**
  99      * Alice or Bob's peerID
 100      */
 101     struct GNUNET_PeerIdentity peer;
 102
 103     /**
 104      * the client this request is related to
 105      */
 106     struct GNUNET_SERVER_Client * client;
 107
 108     /**
 109      * The message to send
 110      */
 111     struct GNUNET_MessageHeader * msg;
 112
 113     /**
 114      * how many elements we were supplied with from the client
 115      */
 116     uint16_t element_count;
 117
 118     /**
 119      * how many elements actually are used after applying the mask
 120      */
 121     uint16_t used_element_count;
 122
 123     /**
 124      * how many bytes the mask is long.
 125      * just for convenience so we don't have to re-re-re calculate it each time
 126      */
 127     uint16_t mask_length;
 128
 129     /**
 130      * all the vector elements we received
 131      */
 132     int32_t * vector;
 133
 134     /**
 135      * mask of which elements to check
 136      */
 137     unsigned char * mask;
 138
 139     /**
 140      * Public key of the remote service, only used by bob
 141      */
 142     gcry_sexp_t remote_pubkey;
 143
 144     /**
 145      * E(ai)(Bob) or ai(Alice) after applying the mask
 146      */
 147     gcry_mpi_t * a;
 148
 149     /**
 150      * The computed scalar
 151      */
 152     gcry_mpi_t product;
 153
 154     /**
 155      * My transmit handle for the current message to a alice/bob
 156      */
 157     struct GNUNET_MESH_TransmitHandle * service_transmit_handle;
 158
 159     /**
 160      * My transmit handle for the current message to the client
 161      */
 162     struct GNUNET_SERVER_TransmitHandle * client_transmit_handle;
 163
 164     /**
 165      * tunnel-handle associated with our mesh handle
 166      */
 167     struct GNUNET_MESH_Tunnel * tunnel;
 168
 169     GNUNET_SCHEDULER_TaskIdentifier client_notification_task;
 170
 171     GNUNET_SCHEDULER_TaskIdentifier service_request_task;
 172 };
 173
 174 ///////////////////////////////////////////////////////////////////////////////
 175 //                      Global Variables
 176 ///////////////////////////////////////////////////////////////////////////////
 177
 178
 179 /**
 180  * Handle to the core service (NULL until we've connected to it).
 181  */
 182 static struct GNUNET_MESH_Handle *my_mesh;
 183
 184 /**
 185  * The identity of this host.
 186  */
 187 static struct GNUNET_PeerIdentity me;
 188
 189 /**
 190  * Service's own public key represented as string
 191  */
 192 static unsigned char * my_pubkey_external;
 193
 194 /**
 195  * Service's own public key represented as string
 196  */
 197 static uint16_t my_pubkey_external_length = 0;
 198
 199 /**
 200  * Service's own n
 201  */
 202 static gcry_mpi_t my_n;
 203
 204 /**
 205  * Service's own n^2 (kept for performance)
 206  */
 207 static gcry_mpi_t my_nsquare;
 208
 209 /**
 210  * Service's own public exponent
 211  */
 212 static gcry_mpi_t my_g;
 213
 214 /**
 215  * Service's own private multiplier
 216  */
 217 static gcry_mpi_t my_mu;
 218
 219 /**
 220  * Service's own private exponent
 221  */
 222 static gcry_mpi_t my_lambda;
 223
 224 /**
 225  * Service's offset for values that could possibly be negative but are plaintext for encryption.
 226  */
 227 static gcry_mpi_t my_offset;
 228
 229 /**
 230  * Head of our double linked list for client-requests sent to us.
 231  * for all of these elements we calculate a scalar product with a remote peer
 232  * split between service->service and client->service for simplicity
 233  */
 234 static struct ServiceSession * from_client_head;
 235 /**
 236  * Tail of our double linked list for client-requests sent to us.
 237  * for all of these elements we calculate a scalar product with a remote peer
 238  * split between service->service and client->service for simplicity
 239  */
 240 static struct ServiceSession * from_client_tail;
 241
 242 /**
 243  * Head of our double linked list for service-requests sent to us.
 244  * for all of these elements we help the requesting service in calculating a scalar product
 245  * split between service->service and client->service for simplicity
 246  */
 247 static struct ServiceSession * from_service_head;
 248
 249 /**
 250  * Tail of our double linked list for service-requests sent to us.
 251  * for all of these elements we help the requesting service in calculating a scalar product
 252  * split between service->service and client->service for simplicity
 253  */
 254 static struct ServiceSession * from_service_tail;
 255
 256 /**
 257  * Certain events (callbacks for server & mesh operations) must not be queued after shutdown.
 258  */
 259 static int do_shutdown;
 260
 261 ///////////////////////////////////////////////////////////////////////////////
 262 //                      Helper Functions
 263 ///////////////////////////////////////////////////////////////////////////////
 264
 265 /**
 266  * Generates an Paillier private/public keyset and extracts the values using libgrcypt only
 267  */
 268 static void
 269 generate_keyset ()
 270 {
 271   gcry_sexp_t gen_parms;
 272   gcry_sexp_t key;
 273   gcry_sexp_t tmp_sexp;
 274   gcry_mpi_t p;
 275   gcry_mpi_t q;
 276   gcry_mpi_t tmp1;
 277   gcry_mpi_t tmp2;
 278   gcry_mpi_t gcd;
 279
 280   size_t erroff = 0;
 281
 282   // we can still use the RSA keygen for generating p,q,n, but using e is pointless.
 283   GNUNET_assert (0 == gcry_sexp_build (&gen_parms, &erroff,
 284                                        "(genkey(rsa(nbits %d)(rsa-use-e 3:257)))",
 285                                        KEYBITS));
 286
 287   GNUNET_assert (0 == gcry_pk_genkey (&key, gen_parms));
 288   gcry_sexp_release (gen_parms);
 289
 290   // get n and d of our publickey as MPI
 291   tmp_sexp = gcry_sexp_find_token (key, "n", 0);
 292   GNUNET_assert (tmp_sexp);
 293   my_n = gcry_sexp_nth_mpi (tmp_sexp, 1, GCRYMPI_FMT_USG);
 294   gcry_sexp_release (tmp_sexp);
 295   tmp_sexp = gcry_sexp_find_token (key, "p", 0);
 296   GNUNET_assert (tmp_sexp);
 297   p = gcry_sexp_nth_mpi (tmp_sexp, 1, GCRYMPI_FMT_USG);
 298   gcry_sexp_release (tmp_sexp);
 299   tmp_sexp = gcry_sexp_find_token (key, "q", 0);
 300   GNUNET_assert (tmp_sexp);
 301   q = gcry_sexp_nth_mpi (tmp_sexp, 1, GCRYMPI_FMT_USG);
 302   gcry_sexp_release (key);
 303
 304   tmp1 = gcry_mpi_new (0);
 305   tmp2 = gcry_mpi_new (0);
 306   gcd = gcry_mpi_new (0);
 307   my_g = gcry_mpi_new (0);
 308   my_mu = gcry_mpi_new (0);
 309   my_nsquare = gcry_mpi_new (0);
 310   my_lambda = gcry_mpi_new (0);
 311
 312   // calculate lambda
 313   // lambda = \frac{(p-1)*(q-1)}{gcd(p-1,q-1)}
 314   gcry_mpi_sub_ui (tmp1, p, 1);
 315   gcry_mpi_sub_ui (tmp2, q, 1);
 316   gcry_mpi_gcd (gcd, tmp1, tmp2);
 317   gcry_mpi_set (my_lambda, tmp1);
 318   gcry_mpi_mul (my_lambda, my_lambda, tmp2);
 319   gcry_mpi_div (my_lambda, NULL, my_lambda, gcd, 0);
 320
 321   // generate a g
 322   gcry_mpi_mul (my_nsquare, my_n, my_n);
 323   do
 324     {
 325       // find a matching g
 326       do
 327         {
 328           gcry_mpi_randomize (my_g, KEYBITS * 2, GCRY_WEAK_RANDOM);
 329           // g must be smaller than n^2
 330           if (0 >= gcry_mpi_cmp (my_g, my_nsquare))
 331             continue;
 332
 333           // g must have gcd == 1 with n^2
 334           gcry_mpi_gcd (gcd, my_g, my_nsquare);
 335         }
 336       while (gcry_mpi_cmp_ui (gcd, 1));
 337
 338       // is this a valid g?
 339       // if so, gcd(((g^lambda mod n^2)-1 )/n, n) = 1
 340       gcry_mpi_powm (tmp1, my_g, my_lambda, my_nsquare);
 341       gcry_mpi_sub_ui (tmp1, tmp1, 1);
 342       gcry_mpi_div (tmp1, NULL, tmp1, my_n, 0);
 343       gcry_mpi_gcd (gcd, tmp1, my_n);
 344     }
 345   while (gcry_mpi_cmp_ui (gcd, 1));
 346
 347   // calculate our mu based on g and n.
 348   // mu = (((g^lambda mod n^2)-1 )/n)^-1 mod n
 349   gcry_mpi_invm (my_mu, tmp1, my_n);
 350
 351   GNUNET_assert (0 == gcry_sexp_build (&key, &erroff,
 352                                        "(public-key (paillier (n %M)(g %M)))",
 353                                        my_n, my_g));
 354
 355   // get the length of this sexpression
 356   my_pubkey_external_length = gcry_sexp_sprint (key,
 357                                                 GCRYSEXP_FMT_CANON,
 358                                                 NULL,
 359                                                 UINT16_MAX);
 360
 361   GNUNET_assert (my_pubkey_external_length > 0);
 362   my_pubkey_external = GNUNET_malloc (my_pubkey_external_length);
 363
 364   // convert the sexpression to canonical format
 365   gcry_sexp_sprint (key,
 366                     GCRYSEXP_FMT_CANON,
 367                     my_pubkey_external,
 368                     my_pubkey_external_length);
 369
 370   gcry_sexp_release (key);
 371
 372   // offset has to be sufficiently small to allow computation of:
 373   // m1+m2 mod n == (S + a) + (S + b) mod n,
 374   // if we have more complex operations, this factor needs to be lowered
 375   my_offset = gcry_mpi_new(KEYBITS/3);
 376   gcry_mpi_set_bit(my_offset, KEYBITS/3);
 377
 378   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Generated key set with key length %d bits.\n"), KEYBITS);
 379 }
 380
 381
 382 /**
 383  * If target != size, move target bytes to the
 384  * end of the size-sized buffer and zero out the
 385  * first target-size bytes.
 386  *
 387  * @param buf original buffer
 388  * @param size number of bytes in the buffer
 389  * @param target target size of the buffer
 390  */
 391 static void
 392 adjust (unsigned char *buf, size_t size, size_t target)
 393 {
 394   if (size < target)
 395     {
 396       memmove (&buf[target - size], buf, size);
 397       memset (buf, 0, target - size);
 398     }
 399 }
 400
 401
 402 /**
 403  * encrypts an element using the paillier crypto system
 404  *
 405  * @param c ciphertext (output)
 406  * @param m plaintext
 407  * @param g the public base
 408  * @param n the module from which which r is chosen (Z*_n)
 409  * @param n_square the module for encryption, for performance reasons.
 410  */
 411 static void
 412 encrypt_element (gcry_mpi_t c, gcry_mpi_t m, gcry_mpi_t g, gcry_mpi_t n, gcry_mpi_t n_square)
 413 {
 414   gcry_mpi_t tmp;
 415
 416   GNUNET_assert (tmp = gcry_mpi_new (0));
 417
 418   while (0 >= gcry_mpi_cmp_ui (tmp, 1))
 419     {
 420       gcry_mpi_randomize (tmp, KEYBITS / 3, GCRY_WEAK_RANDOM);
 421       // r must be 1 < r < n
 422     }
 423
 424   gcry_mpi_powm (c, g, m, n_square);
 425   gcry_mpi_powm (tmp, tmp, n, n_square);
 426   gcry_mpi_mulm (c, tmp, c, n_square);
 427
 428   gcry_mpi_release (tmp);
 429 }
 430
 431 /**
 432  * decrypts an element using the paillier crypto system
 433  *
 434  * @param m plaintext (output)
 435  * @param c the ciphertext
 436  * @param mu the modifier to correct encryption
 437  * @param lambda the private exponent
 438  * @param n the outer module for decryption
 439  * @param n_square the inner module for decryption
 440  */
 441 static void
 442 decrypt_element (gcry_mpi_t m, gcry_mpi_t c, gcry_mpi_t mu, gcry_mpi_t lambda, gcry_mpi_t n, gcry_mpi_t n_square)
 443 {
 444   gcry_mpi_powm (m, c, lambda, n_square);
 445   gcry_mpi_sub_ui (m, m, 1);
 446   gcry_mpi_div (m, NULL, m, n, 0);
 447   gcry_mpi_mulm (m, m, mu, n);
 448 }
 449
 450
 451 /**
 452  * computes the square sum over a vector of a given length.
 453  *
 454  * @param vector the vector to encrypt
 455  * @param length the length of the vector
 456  * @return an MPI value containing the calculated sum, never NULL
 457  */
 458 static gcry_mpi_t
 459 compute_square_sum (gcry_mpi_t * vector, uint16_t length)
 460 {
 461   gcry_mpi_t elem;
 462   gcry_mpi_t sum;
 463   int32_t i;
 464
 465   GNUNET_assert (sum = gcry_mpi_new (0));
 466   GNUNET_assert (elem = gcry_mpi_new (0));
 467
 468   // calculare E(sum (ai ^ 2), publickey)
 469   for (i = 0; i < length; i++)
 470     {
 471       gcry_mpi_mul (elem, vector[i], vector[i]);
 472       gcry_mpi_add (sum, sum, elem);
 473     }
 474   gcry_mpi_release (elem);
 475
 476   return sum;
 477 }
 478
 479
 480 /**
 481  * Primitive callback for copying over a message, as they
 482  * usually are too complex to be handled in the callback itself.
 483  * clears a session-callback, if a session was handed over and the transmit handle was stored
 484  *
 485  * @param cls the message object
 486  * @param size the size of the buffer we got
 487  * @param buf the buffer to copy the message to
 488  * @return 0 if we couldn't copy, else the size copied over
 489  */
 490 static size_t
 491 do_send_message (void *cls, size_t size, void *buf)
 492 {
 493   struct ServiceSession * session = cls;
 494   size_t written = 0;
 495
 496   GNUNET_assert (buf);
 497
 498   if (ntohs (session->msg->size) == size)
 499     {
 500       memcpy (buf, session->msg, size);
 501       written = size;
 502     }
 503
 504   if (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT == ntohs(session->msg->type)){
 505     session->state = FINALIZED;
 506     session->client_transmit_handle = NULL;
 507   }
 508   else
 509     session->service_transmit_handle = NULL;
 510
 511   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 512               "Sent a message of type %hu.\n",
 513               ntohs (session->msg->type));
 514   GNUNET_free(session->msg);
 515   session->msg = NULL;
 516
 517   return written;
 518 }
 519
 520
 521 /**
 522  * initializes a new vector with fresh MPI values (=0) of a given length
 523  *
 524  * @param length of the vector to create
 525  * @return the initialized vector, never NULL
 526  */
 527 static gcry_mpi_t *
 528 initialize_mpi_vector (uint16_t length)
 529 {
 530   uint32_t i;
 531   gcry_mpi_t * output = GNUNET_malloc (sizeof (gcry_mpi_t) * length);
 532
 533   for (i = 0; i < length; i++)
 534     GNUNET_assert (NULL != (output[i] = gcry_mpi_new (0)));
 535   return output;
 536 }
 537
 538
 539 /**
 540  * permutes an MPI vector according to the given permutation vector
 541  *
 542  * @param vector the vector to permuted
 543  * @param perm the permutation to use
 544  * @param length the length of the vectors
 545  * @return the permuted vector (same as input), never NULL
 546  */
 547 static gcry_mpi_t *
 548 permute_vector (gcry_mpi_t * vector,
 549                 unsigned int * perm,
 550                 uint32_t length)
 551 {
 552   gcry_mpi_t tmp[length];
 553   uint32_t i;
 554
 555   GNUNET_assert (length > 0);
 556
 557   // backup old layout
 558   memcpy (tmp, vector, length * sizeof (gcry_mpi_t));
 559
 560   // permute vector according to given
 561   for (i = 0; i < length; i++)
 562     vector[i] = tmp[perm[i]];
 563
 564   return vector;
 565 }
 566
 567
 568 /**
 569  * Populate a vector with random integer values and convert them to
 570  *
 571  * @param length the length of the vector we must generate
 572  * @return an array of MPI values with random values
 573  */
 574 static gcry_mpi_t *
 575 generate_random_vector (uint16_t length)
 576 {
 577   gcry_mpi_t * random_vector;
 578   int32_t value;
 579   uint32_t i;
 580
 581   random_vector = initialize_mpi_vector (length);
 582   for (i = 0; i < length; i++)
 583     {
 584       value = (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
 585
 586       // long to gcry_mpi_t
 587       if (value < 0)
 588         gcry_mpi_sub_ui (random_vector[i],
 589                          random_vector[i],
 590                          -value);
 591       else
 592         random_vector[i] = gcry_mpi_set_ui (random_vector[i], value);
 593     }
 594
 595   return random_vector;
 596 }
 597
 598
 599 /**
 600  * Finds a not terminated client/service session in the
 601  * given DLL based on session key, element count and state.
 602  *
 603  * @param tail - the tail of the DLL
 604  * @param my - the session to compare it to
 605  * @return a pointer to a matching session,
 606  *         else NULL
 607  */
 608 static struct ServiceSession *
 609 find_matching_session (struct ServiceSession * tail,
 610                        const struct GNUNET_HashCode * key,
 611                        uint16_t element_count,
 612                        enum SessionState * state,
 613                        const struct GNUNET_PeerIdentity * peerid)
 614 {
 615   struct ServiceSession * curr;
 616
 617   for (curr = tail; NULL != curr; curr = curr->prev)
 618     {
 619       // if the key matches, and the element_count is same
 620       if ((!memcmp (&curr->key, key, sizeof (struct GNUNET_HashCode)))
 621           && (curr->element_count == element_count))
 622         {
 623           // if incoming state is NULL OR is same as state of the queued request
 624           if ((NULL == state) || (curr->state == *state))
 625             {
 626               // if peerid is NULL OR same as the peer Id in the queued request
 627               if ((NULL == peerid)
 628                   || (!memcmp (&curr->peer, peerid, sizeof (struct GNUNET_PeerIdentity))))
 629                 // matches and is not an already terminated session
 630                 return curr;
 631             }
 632         }
 633     }
 634
 635   return NULL;
 636 }
 637
 638
 639 static void
 640 free_session (struct ServiceSession * session)
 641 {
 642   unsigned int i;
 643
 644   if (session->a)
 645   {
 646     for (i = 0; i < session->used_element_count; i++)
 647       gcry_mpi_release (session->a[i]);
 648
 649     GNUNET_free (session->a);
 650   }
 651   if (session->product)
 652     gcry_mpi_release (session->product);
 653
 654   if (session->remote_pubkey)
 655     gcry_sexp_release (session->remote_pubkey);
 656
 657   GNUNET_free_non_null (session->vector);
 658   GNUNET_free (session);
 659 }
 660 ///////////////////////////////////////////////////////////////////////////////
 661 //                      Event and Message Handlers
 662 ///////////////////////////////////////////////////////////////////////////////
 663
 664 /**
 665  * A client disconnected.
 666  *
 667  * Remove the associated session(s), release datastructures
 668  * and cancel pending outgoing transmissions to the client.
 669  * if the session has not yet completed, we also cancel Alice's request to Bob.
 670  *
 671  * @param cls closure, NULL
 672  * @param client identification of the client
 673  */
 674 static void
 675 handle_client_disconnect (void *cls,
 676                           struct GNUNET_SERVER_Client *client)
 677 {
 678   struct ServiceSession *session;
 679
 680   session = GNUNET_SERVER_client_get_user_context (client, struct ServiceSession);
 681   if (NULL == session)
 682     return;
 683   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 684               _ ("Client (%p) disconnected from us.\n"), client);
 685   GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, session);
 686
 687   if (!(session->role == BOB && session->state == FINALIZED))
 688     {
 689       //we MUST terminate any client message underway
 690       if (session->service_transmit_handle && session->tunnel)
 691         GNUNET_MESH_notify_transmit_ready_cancel (session->service_transmit_handle);
 692       if (session->tunnel && session->state == WAITING_FOR_RESPONSE_FROM_SERVICE)
 693         GNUNET_MESH_tunnel_destroy (session->tunnel);
 694     }
 695   if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task)
 696     {
 697       GNUNET_SCHEDULER_cancel (session->client_notification_task);
 698       session->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
 699     }
 700   if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task)
 701     {
 702       GNUNET_SCHEDULER_cancel (session->service_request_task);
 703       session->service_request_task = GNUNET_SCHEDULER_NO_TASK;
 704     }
 705   if (NULL != session->client_transmit_handle)
 706     {
 707       GNUNET_SERVER_notify_transmit_ready_cancel (session->client_transmit_handle);
 708       session->client_transmit_handle = NULL;
 709     }
 710   free_session (session);
 711 }
 712
 713
 714 /**
 715  * Notify the client that the session has succeeded or failed completely.
 716  * This message gets sent to
 717  * * alice's client if bob disconnected or to
 718  * * bob's client if the operation completed or alice disconnected
 719  *
 720  * @param client_session the associated client session
 721  * @return GNUNET_NO, if we could not notify the client
 722  *         GNUNET_YES if we notified it.
 723  */
 724 static void
 725 prepare_client_end_notification (void * cls,
 726                                  const struct GNUNET_SCHEDULER_TaskContext * tc)
 727 {
 728   struct ServiceSession * session = cls;
 729   struct GNUNET_SCALARPRODUCT_client_response * msg;
 730
 731   session->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
 732
 733   msg = GNUNET_new (struct GNUNET_SCALARPRODUCT_client_response);
 734   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT);
 735   memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
 736   memcpy (&msg->peer, &session->peer, sizeof ( struct GNUNET_PeerIdentity));
 737   msg->header.size = htons (sizeof (struct GNUNET_SCALARPRODUCT_client_response));
 738   // 0 size and the first char in the product is 0, which should never be zero if encoding is used.
 739   msg->product_length = htonl (0);
 740   msg->range = 1;
 741
 742   session->msg = &msg->header;
 743
 744   //transmit this message to our client
 745   session->client_transmit_handle =
 746           GNUNET_SERVER_notify_transmit_ready (session->client,
 747                                                sizeof (struct GNUNET_SCALARPRODUCT_client_response),
 748                                                GNUNET_TIME_UNIT_FOREVER_REL,
 749                                                &do_send_message,
 750                                                session);
 751
 752   // if we could not even queue our request, something is wrong
 753   if ( ! session->client_transmit_handle)
 754     {
 755       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not send message to client (%p)! This is OK if it was disconnected beforehand already.\n"), session->client);
 756       // usually gets freed by do_send_message
 757       GNUNET_free (msg_obj);
 758       GNUNET_free (msg);
 759     }
 760   else
 761     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Sending session-end notification to client (%p) for session %s\n"), &session->client, GNUNET_h2s (&session->key));
 762
 763 }
 764
 765
 766 /**
 767  * Bob executes:
 768  * generates the response message to be sent to alice after computing
 769  * the values (1), (2), S and S'
 770  *  (1)[]: $E_A(a_{pi(i)}) times E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$
 771  *  (2)[]: $E_A(a_{pi'(i)}) times E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$
 772  *      S: $S := E_A(sum (r_i + b_i)^2)$
 773  *     S': $S' := E_A(sum r_i^2)$
 774  *
 775  * @param r    (1)[]: $E_A(a_{pi(i)}) times E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$
 776  * @param r_prime    (2)[]: $E_A(a_{pi'(i)}) times E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$
 777  * @param s         S: $S := E_A(sum (r_i + b_i)^2)$
 778  * @param s_prime    S': $S' := E_A(sum r_i^2)$
 779  * @param request  the associated requesting session with alice
 780  * @param response the associated responder session with bob's client
 781  * @return GNUNET_SYSERR if the function was called with NULL parameters or if there was an error
 782  *         GNUNET_NO if we could not send our message
 783  *         GNUNET_OK if the operation succeeded
 784  */
 785 static int
 786 prepare_service_response (gcry_mpi_t * r,
 787                           gcry_mpi_t * r_prime,
 788                           gcry_mpi_t s,
 789                           gcry_mpi_t s_prime,
 790                           struct ServiceSession * request,
 791                           struct ServiceSession * response)
 792 {
 793   struct GNUNET_SCALARPRODUCT_service_response * msg;
 794   uint16_t msg_length = 0;
 795   unsigned char * current = NULL;
 796   unsigned char * element_exported = NULL;
 797   size_t element_length = 0;
 798   int i;
 799
 800   msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
 801           + 2 * request->used_element_count * PAILLIER_ELEMENT_LENGTH // kp, kq
 802           + 2 * PAILLIER_ELEMENT_LENGTH; // s, stick
 803
 804   msg = GNUNET_malloc (msg_length);
 805
 806   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE);
 807   msg->header.size = htons (msg_length);
 808   msg->element_count = htons (request->element_count);
 809   msg->used_element_count = htons (request->used_element_count);
 810   memcpy (&msg->key, &request->key, sizeof (struct GNUNET_HashCode));
 811   current = (unsigned char *) &msg[1];
 812
 813   // 4 times the same logics with slight variations.
 814   // doesn't really justify having 2 functions for that
 815   // so i put it into blocks to enhance readability
 816   // convert s
 817   {
 818     element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH);
 819     GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
 820                                         element_exported, PAILLIER_ELEMENT_LENGTH,
 821                                         &element_length,
 822                                         s));
 823     adjust (element_exported, element_length, PAILLIER_ELEMENT_LENGTH);
 824     memcpy (current, element_exported, PAILLIER_ELEMENT_LENGTH);
 825     GNUNET_free (element_exported);
 826     current += PAILLIER_ELEMENT_LENGTH;
 827   }
 828
 829   // convert stick
 830   {
 831     element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH);
 832     GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
 833                                         element_exported, PAILLIER_ELEMENT_LENGTH,
 834                                         &element_length,
 835                                         s_prime));
 836     adjust (element_exported, element_length, PAILLIER_ELEMENT_LENGTH);
 837     memcpy (current, element_exported, PAILLIER_ELEMENT_LENGTH);
 838     GNUNET_free (element_exported);
 839     current += PAILLIER_ELEMENT_LENGTH;
 840   }
 841
 842   // convert kp[]
 843   for (i = 0; i < request->used_element_count; i++)
 844     {
 845       element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH);
 846       GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
 847                                           element_exported, PAILLIER_ELEMENT_LENGTH,
 848                                           &element_length,
 849                                           r[i]));
 850       adjust (element_exported, element_length, PAILLIER_ELEMENT_LENGTH);
 851       memcpy (current, element_exported, PAILLIER_ELEMENT_LENGTH);
 852       GNUNET_free (element_exported);
 853       current += PAILLIER_ELEMENT_LENGTH;
 854     }
 855
 856
 857   // convert kq[]
 858   for (i = 0; i < request->used_element_count; i++)
 859     {
 860       element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH);
 861       GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
 862                                           element_exported, PAILLIER_ELEMENT_LENGTH,
 863                                           &element_length,
 864                                           r_prime[i]));
 865       adjust (element_exported, element_length, PAILLIER_ELEMENT_LENGTH);
 866       memcpy (current, element_exported, PAILLIER_ELEMENT_LENGTH);
 867       GNUNET_free (element_exported);
 868       current += PAILLIER_ELEMENT_LENGTH;
 869     }
 870
 871   if (GNUNET_SERVER_MAX_MESSAGE_SIZE >= msg_length)
 872     {
 873       struct MessageObject * msg_obj;
 874
 875       msg_obj = GNUNET_new (struct MessageObject);
 876       msg_obj->msg = (struct GNUNET_MessageHeader *) msg;
 877       msg_obj->transmit_handle = (void *) &request->service_transmit_handle; //and reset the transmit handle
 878       request->service_transmit_handle =
 879               GNUNET_MESH_notify_transmit_ready (request->tunnel,
 880                                                  GNUNET_YES,
 881                                                  GNUNET_TIME_UNIT_FOREVER_REL,
 882                                                  msg_length,
 883                                                  &do_send_message,
 884                                                  msg_obj);
 885       // we don't care if it could be send or not. either way, the session is over for us.
 886       request->state = FINALIZED;
 887       response->state = FINALIZED;
 888     }
 889   else
 890     {
 891       // TODO FEATURE: fallback to fragmentation, in case the message is too long
 892       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Message too large, fragmentation is currently not supported!)\n"));
 893     }
 894
 895   //disconnect our client
 896   if ( ! request->service_transmit_handle)
 897     {
 898       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-response message via mesh!)\n"));
 899
 900       response->client_notification_task =
 901               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
 902                                         response);
 903       return GNUNET_NO;
 904     }
 905   return GNUNET_OK;
 906 }
 907
 908
 909 /**
 910  * executed by bob:
 911  * compute the values
 912  *  (1)[]: $E_A(a_{\pi(i)}) \otimes E_A(- r_{\pi(i)} - b_{\pi(i)}) &= E_A(a_{\pi(i)} - r_{\pi(i)} - b_{\pi(i)})$
 913  *  (2)[]: $E_A(a_{\pi'(i)}) \otimes E_A(- r_{\pi'(i)}) &= E_A(a_{\pi'(i)} - r_{\pi'(i)})$
 914  *      S: $S := E_A(\sum (r_i + b_i)^2)$
 915  *     S': $S' := E_A(\sum r_i^2)$
 916  *
 917  * @param request the requesting session + bob's requesting peer
 918  * @param response the responding session + bob's client handle
 919  * @return GNUNET_SYSERR if the computation failed
 920  *         GNUNET_OK if everything went well.
 921  */
 922 static int
 923 compute_service_response (struct ServiceSession * request,
 924                           struct ServiceSession * response)
 925 {
 926   int i;
 927   int j;
 928   int ret = GNUNET_SYSERR;
 929   unsigned int * p;
 930   unsigned int * q;
 931   uint16_t count;
 932   gcry_mpi_t * rand = NULL;
 933   gcry_mpi_t * r = NULL;
 934   gcry_mpi_t * r_prime = NULL;
 935   gcry_mpi_t * b;
 936   gcry_mpi_t * a_pi;
 937   gcry_mpi_t * a_pi_prime;
 938   gcry_mpi_t * b_pi;
 939   gcry_mpi_t * rand_pi;
 940   gcry_mpi_t * rand_pi_prime;
 941   gcry_mpi_t s = NULL;
 942   gcry_mpi_t s_prime = NULL;
 943   gcry_mpi_t remote_n = NULL;
 944   gcry_mpi_t remote_nsquare;
 945   gcry_mpi_t remote_g = NULL;
 946   gcry_sexp_t tmp_exp;
 947   uint32_t value;
 948
 949   count = request->used_element_count;
 950
 951   b = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 952   a_pi = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 953   b_pi = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 954   a_pi_prime = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 955   rand_pi = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 956   rand_pi_prime = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
 957
 958   // convert responder session to from long to mpi
 959   for (i = 0, j = 0; i < response->element_count && j < count; i++)
 960     {
 961       if (request->mask[i / 8] & (1 << (i % 8)))
 962         {
 963           value = response->vector[i] >= 0 ? response->vector[i] : -response->vector[i];
 964           // long to gcry_mpi_t
 965           if (0 > response->vector[i])
 966             {
 967               b[j] = gcry_mpi_new (0);
 968               gcry_mpi_sub_ui (b[j], b[j], value);
 969             }
 970           else
 971             {
 972               b[j] = gcry_mpi_set_ui (NULL, value);
 973             }
 974           j++;
 975         }
 976     }
 977   GNUNET_free (response->vector);
 978   response->vector = NULL;
 979
 980   tmp_exp = gcry_sexp_find_token (request->remote_pubkey, "n", 0);
 981   if ( ! tmp_exp)
 982     {
 983       GNUNET_break_op (0);
 984       gcry_sexp_release (request->remote_pubkey);
 985       request->remote_pubkey = NULL;
 986       goto except;
 987     }
 988   remote_n = gcry_sexp_nth_mpi (tmp_exp, 1, GCRYMPI_FMT_USG);
 989   if ( ! remote_n)
 990     {
 991       GNUNET_break (0);
 992       gcry_sexp_release (tmp_exp);
 993       goto except;
 994     }
 995   remote_nsquare = gcry_mpi_new (KEYBITS + 1);
 996   gcry_mpi_mul (remote_nsquare, remote_n, remote_n);
 997   gcry_sexp_release (tmp_exp);
 998   tmp_exp = gcry_sexp_find_token (request->remote_pubkey, "g", 0);
 999   gcry_sexp_release (request->remote_pubkey);
1000   request->remote_pubkey = NULL;
1001   if ( ! tmp_exp)
1002     {
1003       GNUNET_break_op (0);
1004       gcry_mpi_release (remote_n);
1005       goto except;
1006     }
1007   remote_g = gcry_sexp_nth_mpi (tmp_exp, 1, GCRYMPI_FMT_USG);
1008   if ( ! remote_g)
1009     {
1010       GNUNET_break (0);
1011       gcry_mpi_release (remote_n);
1012       gcry_sexp_release (tmp_exp);
1013       goto except;
1014     }
1015   gcry_sexp_release (tmp_exp);
1016
1017   // generate r, p and q
1018   rand = generate_random_vector (count);
1019   p = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK, count);
1020   q = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK, count);
1021   //initialize the result vectors
1022   r = initialize_mpi_vector (count);
1023   r_prime = initialize_mpi_vector (count);
1024
1025   // copy the REFERNCES of a, b and r into aq and bq. we will not change
1026   // those values, thus we can work with the references
1027   memcpy (a_pi, request->a, sizeof (gcry_mpi_t) * count);
1028   memcpy (a_pi_prime, request->a, sizeof (gcry_mpi_t) * count);
1029   memcpy (b_pi, b, sizeof (gcry_mpi_t) * count);
1030   memcpy (rand_pi, rand, sizeof (gcry_mpi_t) * count);
1031   memcpy (rand_pi_prime, rand, sizeof (gcry_mpi_t) * count);
1032
1033   // generate p and q permutations for a, b and r
1034   GNUNET_assert (permute_vector (a_pi, p, count));
1035   GNUNET_assert (permute_vector (b_pi, p, count));
1036   GNUNET_assert (permute_vector (rand_pi, p, count));
1037   GNUNET_assert (permute_vector (a_pi_prime, q, count));
1038   GNUNET_assert (permute_vector (rand_pi_prime, q, count));
1039
1040   // encrypt the element
1041   // for the sake of readability I decided to have dedicated permutation
1042   // vectors, which get rid of all the lookups in p/q.
1043   // however, ap/aq are not absolutely necessary but are just abstraction
1044   // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
1045   for (i = 0; i < count; i++)
1046     {
1047       // E(S - r_pi - b_pi)
1048       gcry_mpi_sub (r[i], my_offset, rand_pi[i]);
1049       gcry_mpi_sub (r[i], r[i], b_pi[i]);
1050       encrypt_element (r[i], r[i], remote_g, remote_n, remote_nsquare);
1051
1052       // E(S - r_pi - b_pi) * E(S + a_pi) ==  E(2*S + a - r - b)
1053       gcry_mpi_mulm (r[i], r[i], a_pi[i], remote_nsquare);
1054     }
1055   GNUNET_free (a_pi);
1056   GNUNET_free (b_pi);
1057   GNUNET_free (rand_pi);
1058
1059   // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
1060   for (i = 0; i < count; i++)
1061     {
1062       // E(S - r_qi)
1063       gcry_mpi_sub (r_prime[i], my_offset, rand_pi_prime[i]);
1064       encrypt_element (r_prime[i], r_prime[i], remote_g, remote_n, remote_nsquare);
1065
1066       // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
1067       gcry_mpi_mulm (r_prime[i], r_prime[i], a_pi_prime[i], remote_nsquare);
1068     }
1069   GNUNET_free (a_pi_prime);
1070   GNUNET_free (rand_pi_prime);
1071
1072   // Calculate S' =  E(SUM( r_i^2 ))
1073   s_prime = compute_square_sum (rand, count);
1074   encrypt_element (s_prime, s_prime, remote_g, remote_n, remote_nsquare);
1075
1076   // Calculate S = E(SUM( (r_i + b_i)^2 ))
1077   for (i = 0; i < count; i++)
1078     {
1079       gcry_mpi_add (rand[i], rand[i], b[i]);
1080     }
1081   s = compute_square_sum (rand, count);
1082   encrypt_element (s, s, remote_g, remote_n, remote_nsquare);
1083   gcry_mpi_release (remote_n);
1084   gcry_mpi_release (remote_g);
1085   gcry_mpi_release (remote_nsquare);
1086
1087   // release r and tmp
1088   for (i = 0; i < count; i++)
1089     // rp, rq, aq, ap, bp, bq are released along with a, r, b respectively, (a and b are handled at except:)
1090     gcry_mpi_release (rand[i]);
1091
1092   // copy the Kp[], Kq[], S and Stick into a new message
1093   if (GNUNET_YES != prepare_service_response (r, r_prime, s, s_prime, request, response))
1094     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Failed to communicate with `%s', scalar product calculation aborted.\n"),
1095                 GNUNET_i2s (&request->peer));
1096   else
1097     ret = GNUNET_OK;
1098
1099   for (i = 0; i < count; i++)
1100     {
1101       gcry_mpi_release (r_prime[i]);
1102       gcry_mpi_release (r[i]);
1103     }
1104
1105   gcry_mpi_release (s);
1106   gcry_mpi_release (s_prime);
1107
1108 except:
1109   for (i = 0; i < count; i++)
1110     {
1111       gcry_mpi_release (b[i]);
1112       gcry_mpi_release (request->a[i]);
1113     }
1114
1115   GNUNET_free (b);
1116   GNUNET_free (request->a);
1117   request->a = NULL;
1118
1119   return ret;
1120 }
1121
1122
1123 /**
1124  * Executed by Alice, fills in a service-request message and sends it to the given peer
1125  *
1126  * @param session the session associated with this request, then also holds the CORE-handle
1127  * @return #GNUNET_SYSERR if we could not send the message
1128  *         #GNUNET_NO if the message was too large
1129  *         #GNUNET_OK if we sent it
1130  */
1131 static void
1132 prepare_service_request (void *cls,
1133                          const struct GNUNET_SCHEDULER_TaskContext *tc)
1134 {
1135   struct ServiceSession * session = cls;
1136   unsigned char * current;
1137   struct GNUNET_SCALARPRODUCT_service_request * msg;
1138   struct MessageObject * msg_obj;
1139   unsigned int i;
1140   unsigned int j;
1141   uint16_t msg_length;
1142   size_t element_length = 0; //gets initialized by gcry_mpi_print, but the compiler doesn't know that
1143   gcry_mpi_t a;
1144   uint32_t value;
1145
1146   session->service_request_task = GNUNET_SCHEDULER_NO_TASK;
1147
1148   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Successfully created new tunnel to peer (%s)!\n"), GNUNET_i2s (&session->peer));
1149
1150   msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request)
1151           + session->used_element_count * PAILLIER_ELEMENT_LENGTH
1152           + session->mask_length
1153           + my_pubkey_external_length;
1154
1155   if (GNUNET_SERVER_MAX_MESSAGE_SIZE < sizeof (struct GNUNET_SCALARPRODUCT_service_request)
1156       + session->used_element_count * PAILLIER_ELEMENT_LENGTH
1157       + session->mask_length
1158       + my_pubkey_external_length)
1159     {
1160       // TODO FEATURE: fallback to fragmentation, in case the message is too long
1161       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Message too large, fragmentation is currently not supported!\n"));
1162       session->client_notification_task =
1163               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1164                                         session);
1165       return;
1166     }
1167   msg = GNUNET_malloc (msg_length);
1168
1169   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB);
1170   memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
1171   msg->mask_length = htons (session->mask_length);
1172   msg->pk_length = htons (my_pubkey_external_length);
1173   msg->used_element_count = htons (session->used_element_count);
1174   msg->element_count = htons (session->element_count);
1175   msg->header.size = htons (msg_length);
1176
1177   // fill in the payload
1178   current = (unsigned char *) &msg[1];
1179   // copy over the mask
1180   memcpy (current, session->mask, session->mask_length);
1181   // copy over our public key
1182   current += session->mask_length;
1183   memcpy (current, my_pubkey_external, my_pubkey_external_length);
1184   current += my_pubkey_external_length;
1185
1186   // now copy over the element vector
1187   session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * session->used_element_count);
1188   a = gcry_mpi_new (KEYBITS * 2);
1189   // encrypt our vector and generate string representations
1190   for (i = 0, j = 0; i < session->element_count; i++)
1191     {
1192       // if this is a used element...
1193       if (session->mask[i / 8] & 1 << (i % 8))
1194         {
1195           unsigned char * element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH);
1196           value = session->vector[i] >= 0 ? session->vector[i] : -session->vector[i];
1197
1198           a = gcry_mpi_set_ui (a, 0);
1199           // long to gcry_mpi_t
1200           if (session->vector[i] < 0)
1201             gcry_mpi_sub_ui (a, a, value);
1202           else
1203             gcry_mpi_add_ui (a, a, value);
1204
1205           session->a[j++] = gcry_mpi_set (NULL, a);
1206           gcry_mpi_add (a, a, my_offset);
1207           encrypt_element (a, a, my_g, my_n, my_nsquare);
1208
1209           // get representation as string
1210           // we always supply some value, so gcry_mpi_print fails only if it can't reserve memory
1211           GNUNET_assert ( ! gcry_mpi_print (GCRYMPI_FMT_USG,
1212                                               element_exported, PAILLIER_ELEMENT_LENGTH,
1213                                               &element_length,
1214                                               a));
1215
1216           // move buffer content to the end of the buffer so it can easily be read by libgcrypt. also this now has fixed size
1217           adjust (element_exported, element_length, PAILLIER_ELEMENT_LENGTH);
1218
1219           // copy over to the message
1220           memcpy (current, element_exported, PAILLIER_ELEMENT_LENGTH);
1221           current += PAILLIER_ELEMENT_LENGTH;
1222         }
1223     }
1224   gcry_mpi_release (a);
1225
1226   msg_obj = GNUNET_new (struct MessageObject);
1227   msg_obj->msg = (struct GNUNET_MessageHeader *) msg;
1228   msg_obj->transmit_handle = (void *) &session->service_transmit_handle; //and reset the transmit handle
1229   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transmitting service request.\n"));
1230
1231   //transmit via mesh messaging
1232   session->state = WAITING_FOR_RESPONSE_FROM_SERVICE;
1233   session->service_transmit_handle = GNUNET_MESH_notify_transmit_ready (session->tunnel, GNUNET_YES,
1234                                                                         GNUNET_TIME_UNIT_FOREVER_REL,
1235                                                                         msg_length,
1236                                                                         &do_send_message,
1237                                                                         msg_obj);
1238   if ( ! session->service_transmit_handle)
1239     {
1240       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not send mutlicast message to tunnel!\n"));
1241       GNUNET_free (msg_obj);
1242       GNUNET_free (msg);
1243       session->client_notification_task =
1244               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1245                                         session);
1246     }
1247 }
1248
1249 /**
1250  * Handler for a client request message.
1251  * Can either be type A or B
1252  *   A: request-initiation to compute a scalar product with a peer
1253  *   B: response role, keep the values + session and wait for a matching session or process a waiting request
1254  *
1255  * @param cls closure
1256  * @param client identification of the client
1257  * @param message the actual message
1258  */
1259 static void
1260 handle_client_request (void *cls,
1261                        struct GNUNET_SERVER_Client *client,
1262                        const struct GNUNET_MessageHeader *message)
1263 {
1264   const struct GNUNET_SCALARPRODUCT_client_request * msg = (const struct GNUNET_SCALARPRODUCT_client_request *) message;
1265   struct ServiceSession * session;
1266   uint16_t element_count;
1267   uint16_t mask_length;
1268   uint16_t msg_type;
1269   int32_t * vector;
1270   uint32_t i;
1271
1272   GNUNET_SERVER_client_get_user_context (client, session);
1273   if ((NULL != session) && (session->state != FINALIZED)){
1274     // only one concurrent session per client connection allowed
1275     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1276     return;
1277   }
1278   else if(NULL != session){
1279     // old session is already completed, clean it up
1280     GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, session);
1281     free_session(session);
1282   }
1283
1284   //we need at least a peer and one message id to compare
1285   if (sizeof (struct GNUNET_SCALARPRODUCT_client_request) > ntohs (msg->header.size))
1286     {
1287       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1288                   _ ("Too short message received from client!\n"));
1289       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1290       return;
1291     }
1292
1293   msg_type = ntohs (msg->header.type);
1294   element_count = ntohs (msg->element_count);
1295   mask_length = ntohs (msg->mask_length);
1296
1297   //sanity check: is the message as long as the message_count fields suggests?
1298   if (( ntohs (msg->header.size) != (sizeof (struct GNUNET_SCALARPRODUCT_client_request) + element_count * sizeof (int32_t) + mask_length))
1299       || (0 == element_count))
1300     {
1301       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1302                   _ ("Invalid message received from client, session information incorrect!\n"));
1303       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1304       return;
1305     }
1306
1307   // do we have a duplicate session here already?
1308   if (NULL != find_matching_session (from_client_tail,
1309                                      &msg->key,
1310                                      element_count,
1311                                      NULL, NULL))
1312     {
1313       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1314                   _ ("Duplicate session information received, cannot create new session with key `%s'\n"),
1315                   GNUNET_h2s (&msg->key));
1316       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1317       return;
1318     }
1319
1320   session = GNUNET_new (struct ServiceSession);
1321   //FIXME: this actually should not happen here!
1322   GNUNET_SERVER_client_set_user_context (client, session);
1323   session->service_request_task = GNUNET_SCHEDULER_NO_TASK;
1324   session->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
1325   session->client = client;
1326   session->element_count = element_count;
1327   session->mask_length = mask_length;
1328   // get our transaction key
1329   memcpy (&session->key, &msg->key, sizeof (struct GNUNET_HashCode));
1330   //allocate memory for vector and encrypted vector
1331   session->vector = GNUNET_malloc (sizeof (int32_t) * element_count);
1332   vector = (int32_t *) & msg[1];
1333
1334   if (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE == msg_type)
1335     {
1336       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1337                   _ ("Got client-request-session with key %s, preparing tunnel to remote service.\n"),
1338                   GNUNET_h2s (&session->key));
1339
1340       session->role = ALICE;
1341       // fill in the mask
1342       session->mask = GNUNET_malloc (mask_length);
1343       memcpy (session->mask, &vector[element_count], mask_length);
1344
1345       // copy over the elements
1346       session->used_element_count = 0;
1347       for (i = 0; i < element_count; i++)
1348         {
1349           session->vector[i] = ntohl (vector[i]);
1350           if (session->vector[i] == 0)
1351             session->mask[i / 8] &= ~(1 << (i % 8));
1352           if (session->mask[i / 8] & (1 << (i % 8)))
1353             session->used_element_count++;
1354         }
1355
1356       if ( ! session->used_element_count)
1357         {
1358           GNUNET_break_op (0);
1359           GNUNET_free (session->vector);
1360           GNUNET_free (session->a);
1361           GNUNET_free (session);
1362           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1363           return;
1364         }
1365       //session with ourself makes no sense!
1366       if ( ! memcmp (&msg->peer, &me, sizeof (struct GNUNET_PeerIdentity)))
1367         {
1368           GNUNET_break (0);
1369           GNUNET_free (session->vector);
1370           GNUNET_free (session->a);
1371           GNUNET_free (session);
1372           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1373           return;
1374         }
1375       // get our peer ID
1376       memcpy (&session->peer, &msg->peer, sizeof (struct GNUNET_PeerIdentity));
1377       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1378                   _ ("Creating new tunnel to for session with key %s.\n"),
1379                   GNUNET_h2s (&session->key));
1380       GNUNET_CONTAINER_DLL_insert (from_client_head, from_client_tail, session);
1381       session->tunnel = GNUNET_MESH_tunnel_create (my_mesh, session,
1382                                                    &session->peer,
1383                                                    GNUNET_APPLICATION_TYPE_SCALARPRODUCT,
1384                                                    GNUNET_NO,
1385                                                    GNUNET_YES);
1386       //prepare_service_request, tunnel_peer_disconnect_handler,
1387       if ( ! session->tunnel)
1388         {
1389           GNUNET_break (0);
1390           GNUNET_free (session->vector);
1391           GNUNET_free (session->a);
1392           GNUNET_free (session);
1393           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1394           return;
1395         }
1396       session->state = WAITING_FOR_BOBS_CONNECT;
1397
1398       session->service_request_task =
1399               GNUNET_SCHEDULER_add_now (&prepare_service_request,
1400                                         session);
1401
1402     }
1403   else
1404     {
1405       struct ServiceSession * requesting_session;
1406       enum SessionState needed_state = REQUEST_FROM_SERVICE_RECEIVED;
1407
1408       session->role = BOB;
1409       session->mask = NULL;
1410       // copy over the elements
1411       session->used_element_count = element_count;
1412       for (i = 0; i < element_count; i++)
1413         session->vector[i] = ntohl (vector[i]);
1414       session->state = MESSAGE_FROM_RESPONDING_CLIENT_RECEIVED;
1415
1416       GNUNET_CONTAINER_DLL_insert (from_client_head, from_client_tail, session);
1417       //check if service queue contains a matching request
1418       requesting_session = find_matching_session (from_service_tail,
1419                                                   &session->key,
1420                                                   session->element_count,
1421                                                   &needed_state, NULL);
1422       if (NULL != requesting_session)
1423         {
1424           GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got client-responder-session with key %s and a matching service-request-session set, processing.\n"), GNUNET_h2s (&session->key));
1425           if (GNUNET_OK != compute_service_response (requesting_session, session))
1426               session->client_notification_task =
1427                       GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1428                                                 session);
1429
1430         }
1431       else{
1432         GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got client-responder-session with key %s but NO matching service-request-session set, queuing element for later use.\n"), GNUNET_h2s (&session->key));
1433         // no matching session exists yet, store the response
1434         // for later processing by handle_service_request()
1435       }
1436     }
1437   GNUNET_SERVER_receive_done (client, GNUNET_YES);
1438 }
1439
1440
1441 /**
1442  * Function called for inbound tunnels.
1443  *
1444  * @param cls closure
1445  * @param tunnel new handle to the tunnel
1446  * @param initiator peer that started the tunnel
1447  * @param atsi performance information for the tunnel
1448  * @return initial tunnel context for the tunnel
1449  *         (can be NULL -- that's not an error)
1450  */
1451 static void *
1452 tunnel_incoming_handler (void *cls,
1453                          struct GNUNET_MESH_Tunnel *tunnel,
1454                          const struct GNUNET_PeerIdentity *initiator,
1455                          uint32_t port)
1456 {
1457   struct ServiceSession * c = GNUNET_new (struct ServiceSession);
1458
1459   c->peer = *initiator;
1460   c->tunnel = tunnel;
1461   c->role = BOB;
1462   return c;
1463 }
1464
1465
1466 /**
1467  * Function called whenever a tunnel is destroyed.  Should clean up
1468  * any associated state.
1469  *
1470  * It must NOT call GNUNET_MESH_tunnel_destroy on the tunnel.
1471  *
1472  * @param cls closure (set from GNUNET_MESH_connect)
1473  * @param tunnel connection to the other end (henceforth invalid)
1474  * @param tunnel_ctx place where local state associated
1475  *                   with the tunnel is stored
1476  */
1477 static void
1478 tunnel_destruction_handler (void *cls,
1479                             const struct GNUNET_MESH_Tunnel *tunnel,
1480                             void *tunnel_ctx)
1481 {
1482   struct ServiceSession * session = tunnel_ctx;
1483   struct ServiceSession * client_session;
1484   struct ServiceSession * curr;
1485
1486   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1487               _("Peer disconnected, terminating session %s with peer (%s)\n"),
1488               GNUNET_h2s (&session->key),
1489               GNUNET_i2s (&session->peer));
1490   if (ALICE == session->role) {
1491     // as we have only one peer connected in each session, just remove the session
1492
1493     if ((FINALIZED != session->state) && (!do_shutdown))
1494     {
1495       session->tunnel = NULL;
1496       // if this happened before we received the answer, we must terminate the session
1497       session->client_notification_task =
1498               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1499                                         session);
1500     }
1501   }
1502   else { //(BOB == session->role) service session
1503
1504     // remove the session, unless it has already been dequeued, but somehow still active
1505     // this could bug without the IF in case the queue is empty and the service session was the only one know to the service
1506     // scenario: disconnect before alice can send her message to bob.
1507     for (curr = from_service_head; NULL != curr; curr = curr->next)
1508       if (curr == session)
1509       {
1510         GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, curr);
1511         break;
1512       }
1513     // there is a client waiting for this service session, terminate it, too!
1514     // i assume the tupel of key and element count is unique. if it was not the rest of the code would not work either.
1515     client_session = find_matching_session (from_client_tail,
1516                                             &session->key,
1517                                             session->element_count,
1518                                             NULL, NULL);
1519     free_session (session);
1520
1521     // the client has to check if it was waiting for a result
1522     // or if it was a responder, no point in adding more statefulness
1523     if (client_session && (!do_shutdown))
1524     {
1525       client_session->client_notification_task =
1526               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1527                                         client_session);
1528     }
1529   }
1530 }
1531
1532
1533 /**
1534  * Compute our scalar product, done by Alice
1535  *
1536  * @param session - the session associated with this computation
1537  * @param kp - (1) from the protocol definition:
1538  *             $E_A(a_{\pi(i)}) \otimes E_A(- r_{\pi(i)} - b_{\pi(i)}) &= E_A(a_{\pi(i)} - r_{\pi(i)} - b_{\pi(i)})$
1539  * @param kq - (2) from the protocol definition:
1540  *             $E_A(a_{\pi'(i)}) \otimes E_A(- r_{\pi'(i)}) &= E_A(a_{\pi'(i)} - r_{\pi'(i)})$
1541  * @param s - S from the protocol definition:
1542  *            $S := E_A(\sum (r_i + b_i)^2)$
1543  * @param stick - S' from the protocol definition:
1544  *                $S' := E_A(\sum r_i^2)$
1545  * @return product as MPI, never NULL
1546  */
1547 static gcry_mpi_t
1548 compute_scalar_product (struct ServiceSession * session,
1549                         gcry_mpi_t * r, gcry_mpi_t * r_prime, gcry_mpi_t s, gcry_mpi_t s_prime)
1550 {
1551   uint16_t count;
1552   gcry_mpi_t t;
1553   gcry_mpi_t u;
1554   gcry_mpi_t utick;
1555   gcry_mpi_t p;
1556   gcry_mpi_t ptick;
1557   gcry_mpi_t tmp;
1558   unsigned int i;
1559
1560   count = session->used_element_count;
1561   tmp = gcry_mpi_new (KEYBITS);
1562   // due to the introduced static offset S, we now also have to remove this
1563   // from the E(a_pi)(+)E(-b_pi-r_pi) and E(a_qi)(+)E(-r_qi) twice each,
1564   // the result is E((S + a_pi) + (S -b_pi-r_pi)) and E(S + a_qi + S - r_qi)
1565   for (i = 0; i < count; i++)
1566     {
1567       decrypt_element (r[i], r[i], my_mu, my_lambda, my_n, my_nsquare);
1568       gcry_mpi_sub(r[i],r[i],my_offset);
1569       gcry_mpi_sub(r[i],r[i],my_offset);
1570       decrypt_element (r_prime[i], r_prime[i], my_mu, my_lambda, my_n, my_nsquare);
1571       gcry_mpi_sub(r_prime[i],r_prime[i],my_offset);
1572       gcry_mpi_sub(r_prime[i],r_prime[i],my_offset);
1573     }
1574
1575   // calculate t = sum(ai)
1576   t = compute_square_sum (session->a, count);
1577
1578   // calculate U
1579   u = gcry_mpi_new (0);
1580   tmp = compute_square_sum (r, count);
1581   gcry_mpi_sub (u, u, tmp);
1582   gcry_mpi_release (tmp);
1583
1584   //calculate U'
1585   utick = gcry_mpi_new (0);
1586   tmp = compute_square_sum (r_prime, count);
1587   gcry_mpi_sub (utick, utick, tmp);
1588
1589   GNUNET_assert (p = gcry_mpi_new (0));
1590   GNUNET_assert (ptick = gcry_mpi_new (0));
1591
1592   // compute P
1593   decrypt_element (s, s, my_mu, my_lambda, my_n, my_nsquare);
1594   decrypt_element (s_prime, s_prime, my_mu, my_lambda, my_n, my_nsquare);
1595
1596   // compute P
1597   gcry_mpi_add (p, s, t);
1598   gcry_mpi_add (p, p, u);
1599
1600   // compute P'
1601   gcry_mpi_add (ptick, s_prime, t);
1602   gcry_mpi_add (ptick, ptick, utick);
1603
1604   gcry_mpi_release (t);
1605   gcry_mpi_release (u);
1606   gcry_mpi_release (utick);
1607
1608   // compute product
1609   gcry_mpi_sub (p, p, ptick);
1610   gcry_mpi_release (ptick);
1611   tmp = gcry_mpi_set_ui (tmp, 2);
1612   gcry_mpi_div (p, NULL, p, tmp, 0);
1613
1614   gcry_mpi_release (tmp);
1615   for (i = 0; i < count; i++)
1616     gcry_mpi_release (session->a[i]);
1617   GNUNET_free (session->a);
1618   session->a = NULL;
1619
1620   return p;
1621 }
1622
1623
1624 /**
1625  * prepare the response we will send to alice or bobs' clients.
1626  * in Bobs case the product will be NULL.
1627  *
1628  * @param session  the session associated with our client.
1629  */
1630 static void
1631 prepare_client_response (void *cls,
1632                          const struct GNUNET_SCHEDULER_TaskContext *tc)
1633 {
1634   struct ServiceSession * session = cls;
1635   struct GNUNET_SCALARPRODUCT_client_response * msg;
1636   unsigned char * product_exported = NULL;
1637   size_t product_length = 0;
1638   uint16_t msg_length = 0;
1639   struct MessageObject * msg_obj;
1640   int8_t range = -1;
1641   gcry_error_t rc;
1642   int sign;
1643
1644   session->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
1645
1646   if (session->product)
1647     {
1648       gcry_mpi_t value = gcry_mpi_new(0);
1649
1650       sign = gcry_mpi_cmp_ui(session->product, 0);
1651       // libgcrypt can not handle a print of a negative number
1652       if (0 > sign){
1653           gcry_mpi_sub(value, value, session->product);
1654       }
1655       else if(0 < sign){
1656           range = 1;
1657           gcry_mpi_add(value, value, session->product);
1658       }
1659       else
1660         range = 0;
1661
1662       // get representation as string
1663       // unfortunately libgcrypt is too stupid to implement print-support in
1664       // signed GCRYMPI_FMT_STD format, and simply asserts in that case.
1665       // here is the associated sourcecode:
1666       // if (a->sign) return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet. */
1667       if (range
1668           && (0 != (rc =  gcry_mpi_aprint (GCRYMPI_FMT_USG,
1669                                              &product_exported,
1670                                              &product_length,
1671                                              session->product)))){
1672         LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
1673         product_length = 0;
1674         range = -1; // signal error with product-length = 0 and range = -1
1675       }
1676
1677       gcry_mpi_release (session->product);
1678       session->product = NULL;
1679     }
1680
1681   msg_length = sizeof (struct GNUNET_SCALARPRODUCT_client_response) + product_length;
1682   msg = GNUNET_malloc (msg_length);
1683   memcpy (&msg[1], product_exported, product_length);
1684   GNUNET_free_non_null (product_exported);
1685   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT);
1686   msg->header.size = htons (msg_length);
1687   msg->range = range;
1688   memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
1689   memcpy (&msg->peer, &session->peer, sizeof ( struct GNUNET_PeerIdentity));
1690   msg->product_length = htonl (product_length);
1691
1692   msg_obj = GNUNET_new (struct MessageObject);
1693   msg_obj->msg = (struct GNUNET_MessageHeader *) msg;
1694   msg_obj->transmit_handle = NULL; // don't reset the transmit handle
1695
1696   //transmit this message to our client
1697   session->client_transmit_handle =
1698           GNUNET_SERVER_notify_transmit_ready (session->client,
1699                                                msg_length,
1700                                                GNUNET_TIME_UNIT_FOREVER_REL,
1701                                                &do_send_message,
1702                                                msg_obj);
1703   if ( ! session->client_transmit_handle)
1704     {
1705       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1706                   _ ("Could not send message to client (%p)! This probably is OK if the client disconnected before us.\n"),
1707                   session->client);
1708       session->client = NULL;
1709       // callback was not called!
1710       GNUNET_free (msg_obj);
1711       GNUNET_free (msg);
1712     }
1713   else
1714       // gracefully sent message, just terminate session structure
1715       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1716                   _ ("Sent result to client (%p), this session (%s) has ended!\n"),
1717                   session->client,
1718                   GNUNET_h2s (&session->key));
1719 }
1720
1721
1722 /**
1723  * Handle a request from another service to calculate a scalarproduct with us.
1724  *
1725  * @param cls closure (set from #GNUNET_MESH_connect)
1726  * @param tunnel connection to the other end
1727  * @param tunnel_ctx place to store local state associated with the tunnel
1728  * @param sender who sent the message
1729  * @param message the actual message
1730  * @param atsi performance data for the connection
1731  * @return #GNUNET_OK to keep the connection open,
1732  *         #GNUNET_SYSERR to close it (signal serious error)
1733  */
1734 static int
1735 handle_service_request (void *cls,
1736                         struct GNUNET_MESH_Tunnel * tunnel,
1737                         void **tunnel_ctx,
1738                         const struct GNUNET_MessageHeader * message)
1739 {
1740   struct ServiceSession * session;
1741   const struct GNUNET_SCALARPRODUCT_service_request * msg = (const struct GNUNET_SCALARPRODUCT_service_request *) message;
1742   uint16_t mask_length;
1743   uint16_t pk_length;
1744   uint16_t used_elements;
1745   uint16_t element_count;
1746   uint16_t msg_length;
1747   unsigned char * current;
1748   struct ServiceSession * responder_session;
1749   int32_t i = -1;
1750   enum SessionState needed_state;
1751
1752   session = (struct ServiceSession *) * tunnel_ctx;
1753   if (BOB != session->role){
1754     GNUNET_break_op(0);
1755     return GNUNET_SYSERR;
1756   }
1757   // is this tunnel already in use?
1758   if ( (session->next) || (from_service_head == session))
1759     {
1760       GNUNET_break_op(0);
1761       return GNUNET_SYSERR;
1762     }
1763   // Check if message was sent by me, which would be bad!
1764   if ( ! memcmp (&session->peer, &me, sizeof (struct GNUNET_PeerIdentity)))
1765     {
1766       GNUNET_break (0);
1767       GNUNET_free (session);
1768       return GNUNET_SYSERR;
1769     }
1770
1771   //we need at least a peer and one message id to compare
1772   if (ntohs (msg->header.size) < sizeof (struct GNUNET_SCALARPRODUCT_service_request))
1773     {
1774       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Too short message received from peer!\n"));
1775       GNUNET_free (session);
1776       return GNUNET_SYSERR;
1777     }
1778   mask_length = ntohs (msg->mask_length);
1779   pk_length = ntohs (msg->pk_length);
1780   used_elements = ntohs (msg->used_element_count);
1781   element_count = ntohs (msg->element_count);
1782   msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request)
1783                + mask_length + pk_length + used_elements * PAILLIER_ELEMENT_LENGTH;
1784
1785   //sanity check: is the message as long as the message_count fields suggests?
1786   if ((ntohs (msg->header.size) != msg_length) || (element_count < used_elements)
1787       || (used_elements == 0) || (mask_length != (element_count / 8 + (element_count % 8 ? 1 : 0)))
1788       )
1789     {
1790       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Invalid message received from peer, message count does not match message length!\n"));
1791       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Used elements: %hu\nElement Count: %hu\nExpected Mask Length: %hu\nCalculated Masklength: %d\n"), used_elements, element_count, mask_length, (element_count / 8 + (element_count % 8 ? 1 : 0)));
1792       GNUNET_free (session);
1793       return GNUNET_SYSERR;
1794     }
1795   if (find_matching_session (from_service_tail,
1796                              &msg->key,
1797                              element_count,
1798                              NULL,
1799                              NULL))
1800     {
1801       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Got message with duplicate session key (`%s'), ignoring service request.\n"), (const char *) &(msg->key));
1802       GNUNET_free (session);
1803       return GNUNET_SYSERR;
1804     }
1805
1806   memcpy (&session->peer, &session->peer, sizeof (struct GNUNET_PeerIdentity));
1807   session->state = REQUEST_FROM_SERVICE_RECEIVED;
1808   session->element_count = ntohs (msg->element_count);
1809   session->used_element_count = used_elements;
1810   session->tunnel = tunnel;
1811
1812   // session key
1813   memcpy (&session->key, &msg->key, sizeof (struct GNUNET_HashCode));
1814   current = (unsigned char *) &msg[1];
1815   //preserve the mask, we will need that later on
1816   session->mask = GNUNET_malloc (mask_length);
1817   memcpy (session->mask, current, mask_length);
1818   //the public key
1819   current += mask_length;
1820
1821   //convert the publickey to sexp
1822   if (gcry_sexp_new (&session->remote_pubkey, current, pk_length, 1))
1823     {
1824       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not translate remote public key to sexpression!\n"));
1825       GNUNET_free (session->mask);
1826       GNUNET_free (session);
1827       return GNUNET_SYSERR;
1828     }
1829
1830   current += pk_length;
1831
1832   //check if service queue contains a matching request
1833   needed_state = MESSAGE_FROM_RESPONDING_CLIENT_RECEIVED;
1834   responder_session = find_matching_session (from_client_tail,
1835                                              &session->key,
1836                                              session->element_count,
1837                                              &needed_state, NULL);
1838
1839   session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * used_elements);
1840
1841   if (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_service_request)
1842       +pk_length
1843       + mask_length
1844       + used_elements * PAILLIER_ELEMENT_LENGTH)
1845     {
1846       gcry_error_t ret = 0;
1847       session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * used_elements);
1848       // Convert each vector element to MPI_value
1849       for (i = 0; i < used_elements; i++)
1850         {
1851           size_t read = 0;
1852
1853           ret = gcry_mpi_scan (&session->a[i],
1854                                GCRYMPI_FMT_USG,
1855                                &current[i * PAILLIER_ELEMENT_LENGTH],
1856                                PAILLIER_ELEMENT_LENGTH,
1857                                &read);
1858           if (ret)
1859             {
1860               GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not translate E[a%d] to MPI!\n%s/%s\n"),
1861                           i, gcry_strsource (ret), gcry_strerror (ret));
1862               goto except;
1863             }
1864         }
1865       GNUNET_CONTAINER_DLL_insert (from_service_head, from_service_tail, session);
1866       if (responder_session)
1867         {
1868           GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s and a matching element set, processing.\n"), GNUNET_h2s (&session->key));
1869           if (GNUNET_OK != compute_service_response (session, responder_session))
1870             {
1871               //something went wrong, remove it again...
1872               GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, session);
1873               goto except;
1874             }
1875         }
1876       else
1877           GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s without a matching element set, queueing.\n"), GNUNET_h2s (&session->key));
1878       return GNUNET_OK;
1879     }
1880   else
1881     {
1882       // TODO FEATURE: fallback to fragmentation, in case the message is too long
1883       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Message too large, fragmentation is currently not supported!\n"));
1884       goto except;
1885     }
1886 except:
1887   for (i = 0; i < used_elements; i++)
1888     if (session->a[i])
1889       gcry_mpi_release (session->a[i]);
1890   gcry_sexp_release (session->remote_pubkey);
1891   session->remote_pubkey = NULL;
1892   GNUNET_free_non_null (session->a);
1893   session->a = NULL;
1894   free_session (session);
1895   // and notify our client-session that we could not complete the session
1896   if (responder_session)
1897     {
1898       // we just found the responder session in this queue
1899       GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, responder_session);
1900       responder_session->client_notification_task =
1901               GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
1902                                         responder_session);
1903     }
1904   return GNUNET_SYSERR;
1905 }
1906
1907
1908 /**
1909  * Handle a response we got from another service we wanted to calculate a scalarproduct with.
1910  *
1911  * @param cls closure (set from #GNUNET_MESH_connect)
1912  * @param tunnel connection to the other end
1913  * @param tunnel_ctx place to store local state associated with the tunnel
1914  * @param sender who sent the message
1915  * @param message the actual message
1916  * @param atsi performance data for the connection
1917  * @return #GNUNET_OK to keep the connection open,
1918  *         #GNUNET_SYSERR to close it (we are done)
1919  */
1920 static int
1921 handle_service_response (void *cls,
1922                          struct GNUNET_MESH_Tunnel * tunnel,
1923                          void **tunnel_ctx,
1924                          const struct GNUNET_MessageHeader * message)
1925 {
1926   struct ServiceSession * session;
1927   const struct GNUNET_SCALARPRODUCT_service_response * msg = (const struct GNUNET_SCALARPRODUCT_service_response *) message;
1928   unsigned char * current;
1929   uint16_t count;
1930   gcry_mpi_t s = NULL;
1931   gcry_mpi_t s_prime = NULL;
1932   size_t read;
1933   size_t i;
1934   uint16_t used_element_count;
1935   size_t msg_size;
1936   gcry_mpi_t * r = NULL;
1937   gcry_mpi_t * r_prime = NULL;
1938   int rc;
1939
1940   GNUNET_assert (NULL != message);
1941   session = (struct ServiceSession *) * tunnel_ctx;
1942   if (ALICE != session->role){
1943     GNUNET_break_op(0);
1944     return GNUNET_SYSERR;
1945   }
1946
1947   count = session->used_element_count;
1948   session->product = NULL;
1949
1950   //we need at least a peer and one message id to compare
1951   if (sizeof (struct GNUNET_SCALARPRODUCT_service_response) > ntohs (msg->header.size))
1952     {
1953       GNUNET_break_op (0);
1954       goto invalid_msg;
1955     }
1956   used_element_count = ntohs (msg->used_element_count);
1957   msg_size = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
1958           + 2 * used_element_count * PAILLIER_ELEMENT_LENGTH
1959           + 2 * PAILLIER_ELEMENT_LENGTH;
1960   //sanity check: is the message as long as the message_count fields suggests?
1961   if ((ntohs (msg->header.size) != msg_size) || (count != used_element_count))
1962     {
1963       GNUNET_break_op (0);
1964       goto invalid_msg;
1965     }
1966
1967   //convert s
1968   current = (unsigned char *) &msg[1];
1969   if (0 != (rc = gcry_mpi_scan (&s, GCRYMPI_FMT_USG, current,
1970                      PAILLIER_ELEMENT_LENGTH, &read)))
1971     {
1972       LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc);
1973       GNUNET_break_op (0);
1974       goto invalid_msg;
1975     }
1976   current += PAILLIER_ELEMENT_LENGTH;
1977   //convert stick
1978   if (0 != (rc = gcry_mpi_scan (&s_prime, GCRYMPI_FMT_USG, current,
1979                        PAILLIER_ELEMENT_LENGTH, &read)))
1980     {
1981       LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc);
1982       GNUNET_break_op (0);
1983       goto invalid_msg;
1984     }
1985   current += PAILLIER_ELEMENT_LENGTH;
1986
1987   r = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
1988   // Convert each kp[] to its MPI_value
1989   for (i = 0; i < count; i++)
1990     {
1991       if (0 != (rc = gcry_mpi_scan (&r[i], GCRYMPI_FMT_USG, current,
1992                            PAILLIER_ELEMENT_LENGTH, &read)))
1993         {
1994           LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc);
1995       GNUNET_break_op (0);
1996           goto invalid_msg;
1997         }
1998       current += PAILLIER_ELEMENT_LENGTH;
1999     }
2000
2001
2002   r_prime = GNUNET_malloc (sizeof (gcry_mpi_t) * count);
2003   // Convert each kq[] to its MPI_value
2004   for (i = 0; i < count; i++)
2005     {
2006       if (0 != (rc = gcry_mpi_scan (&r_prime[i], GCRYMPI_FMT_USG, current,
2007                            PAILLIER_ELEMENT_LENGTH, &read)))
2008         {
2009           LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc);
2010       GNUNET_break_op (0);
2011           goto invalid_msg;
2012         }
2013       current += PAILLIER_ELEMENT_LENGTH;
2014     }
2015
2016   session->product = compute_scalar_product (session, r, r_prime, s, s_prime);
2017
2018 invalid_msg:
2019   if (s)
2020     gcry_mpi_release (s);
2021   if (s_prime)
2022     gcry_mpi_release (s_prime);
2023   for (i = 0; r && i < count; i++)
2024     if (r[i]) gcry_mpi_release (r[i]);
2025   for (i = 0; r_prime && i < count; i++)
2026     if (r_prime[i]) gcry_mpi_release (r_prime[i]);
2027   GNUNET_free_non_null (r);
2028   GNUNET_free_non_null (r_prime);
2029
2030   session->state = FINALIZED;
2031   // the tunnel has done its job, terminate our connection and the tunnel
2032   // the peer will be notified that the tunnel was destroyed via tunnel_destruction_handler
2033   GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, session);
2034   // send message with product to client
2035
2036   session->client_notification_task =
2037           GNUNET_SCHEDULER_add_now (&prepare_client_response,
2038           session);
2039   // just close the connection.
2040   return GNUNET_SYSERR;
2041 }
2042
2043 /**
2044  * Task run during shutdown.
2045  *
2046  * @param cls unused
2047  * @param tc unused
2048  */
2049 static void
2050 shutdown_task (void *cls,
2051                const struct GNUNET_SCHEDULER_TaskContext *tc)
2052 {
2053   struct ServiceSession * session;
2054   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Shutting down, initiating cleanup.\n"));
2055
2056   do_shutdown = GNUNET_YES;
2057
2058   // terminate all owned open tunnels.
2059   for (session = from_client_head; NULL != session; session = session->next)
2060   {
2061     if (FINALIZED != session->state)
2062       GNUNET_MESH_tunnel_destroy (session->tunnel);
2063     if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task)
2064     {
2065       GNUNET_SCHEDULER_cancel (session->client_notification_task);
2066       session->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
2067     }
2068     if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task)
2069     {
2070       GNUNET_SCHEDULER_cancel (session->service_request_task);
2071       session->service_request_task = GNUNET_SCHEDULER_NO_TASK;
2072     }
2073   }
2074   for (session = from_service_head; NULL != session; session = session->next)
2075
2076     if (my_mesh)
2077     {
2078       GNUNET_MESH_disconnect (my_mesh);
2079       my_mesh = NULL;
2080     }
2081 }
2082
2083
2084 /**
2085  * Initialization of the program and message handlers
2086  *
2087  * @param cls closure
2088  * @param server the initialized server
2089  * @param c configuration to use
2090  */
2091 static void
2092 run (void *cls,
2093      struct GNUNET_SERVER_Handle *server,
2094      const struct GNUNET_CONFIGURATION_Handle *c)
2095 {
2096   static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
2097     {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, 0},
2098     {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, 0},
2099     {NULL, NULL, 0, 0}
2100   };
2101   static const struct GNUNET_MESH_MessageHandler mesh_handlers[] = {
2102     { &handle_service_request, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB, 0},
2103     { &handle_service_response, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE, 0},
2104     {NULL, 0, 0}
2105   };
2106   static const uint32_t ports[] = {
2107     GNUNET_APPLICATION_TYPE_SCALARPRODUCT,
2108     0
2109   };
2110   //generate private/public key set
2111   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Generating Paillier-Keyset.\n"));
2112   generate_keyset ();
2113   // register server callbacks and disconnect handler
2114   GNUNET_SERVER_add_handlers (server, server_handlers);
2115   GNUNET_SERVER_disconnect_notify (server,
2116                                    &handle_client_disconnect,
2117                                    NULL);
2118   GNUNET_break (GNUNET_OK ==
2119                 GNUNET_CRYPTO_get_host_identity (c,
2120                                                  &me));
2121   my_mesh = GNUNET_MESH_connect (c, NULL,
2122                                  &tunnel_incoming_handler,
2123                                  &tunnel_destruction_handler,
2124                                  mesh_handlers, ports);
2125   if (!my_mesh)
2126     {
2127       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Connect to MESH failed\n"));
2128       GNUNET_SCHEDULER_shutdown ();
2129       return;
2130     }
2131   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Mesh initialized\n"));
2132   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
2133                                 &shutdown_task,
2134                                 NULL);
2135 }
2136
2137
2138 /**
2139  * The main function for the scalarproduct service.
2140  *
2141  * @param argc number of arguments from the command line
2142  * @param argv command line arguments
2143  * @return 0 ok, 1 on error
2144  */
2145 int
2146 main (int argc, char *const *argv)
2147 {
2148   return (GNUNET_OK ==
2149           GNUNET_SERVICE_run (argc, argv,
2150                               "scalarproduct",
2151                               GNUNET_SERVICE_OPTION_NONE,
2152                               &run, NULL)) ? 0 : 1;
2153 }
2154
2155 /* end of gnunet-service-ext.c */