GNUnet  0.11.x
gnunet-service-scalarproduct-ecc_bob.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013-2017 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your 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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include <limits.h>
28 #include <gcrypt.h>
29 #include "gnunet_util_lib.h"
30 #include "gnunet_core_service.h"
31 #include "gnunet_cadet_service.h"
32 #include "gnunet_applications.h"
33 #include "gnunet_protocols.h"
35 #include "gnunet_set_service.h"
36 #include "scalarproduct.h"
38 
39 #define LOG(kind, ...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
40 
41 
45 struct MpiElement
46 {
52  const struct GNUNET_HashCode *key;
53 
57  gcry_mpi_t value;
58 };
59 
60 
66 {
71 
76 
81 
87 
93 
98 
103 
107  gcry_mpi_point_t prod_g_i_b_i;
108 
112  gcry_mpi_point_t prod_h_i_b_i;
113 
117  uint32_t total;
118 
124 
131 
137 
145 
150 
155 
160 
165 
170 };
171 
172 
176 static const struct GNUNET_CONFIGURATION_Handle *cfg;
177 
182 
187 
188 
196 static int
197 free_element_cb (void *cls,
198  const struct GNUNET_HashCode *key,
199  void *value)
200 {
201  struct GNUNET_SCALARPRODUCT_Element *element = value;
202 
203  GNUNET_free (element);
204  return GNUNET_OK;
205 }
206 
207 
213 static void
215 {
216  unsigned int i;
217 
218  if (GNUNET_YES == s->in_destroy)
219  return;
220  s->in_destroy = GNUNET_YES;
221  if (NULL != s->client)
222  {
223  struct GNUNET_SERVICE_Client *c = s->client;
224 
225  s->client = NULL;
227  }
228  if (NULL != s->intersected_elements)
229  {
232  NULL);
234  s->intersected_elements = NULL;
235  }
236  if (NULL != s->intersection_op)
237  {
239  s->intersection_op = NULL;
240  }
241  if (NULL != s->intersection_set)
242  {
244  s->intersection_set = NULL;
245  }
246  if (NULL != s->sorted_elements)
247  {
248  for (i = 0; i < s->used_element_count; i++)
249  gcry_mpi_release (s->sorted_elements[i].value);
251  s->sorted_elements = NULL;
252  }
253  if (NULL != s->prod_g_i_b_i)
254  {
255  gcry_mpi_point_release (s->prod_g_i_b_i);
256  s->prod_g_i_b_i = NULL;
257  }
258  if (NULL != s->prod_h_i_b_i)
259  {
260  gcry_mpi_point_release (s->prod_h_i_b_i);
261  s->prod_h_i_b_i = NULL;
262  }
263  if (NULL != s->port)
264  {
266  s->port = NULL;
267  }
268  if (NULL != s->channel)
269  {
271  s->channel = NULL;
272  }
273  GNUNET_free (s);
274 }
275 
276 
284 static void
286 {
287  struct ClientResponseMessage *msg;
288  struct GNUNET_MQ_Envelope *e;
289 
290  if (NULL == session->client_mq)
291  return; /* no client left to be notified */
293  "Sending session-end notification with status %d to client for session %s\n",
294  session->status,
295  GNUNET_h2s (&session->session_id));
296  e = GNUNET_MQ_msg (msg,
298  msg->range = 0;
299  msg->product_length = htonl (0);
300  msg->status = htonl (session->status);
301  GNUNET_MQ_send (session->client_mq,
302  e);
303 }
304 
305 
317 static void
319  const struct GNUNET_CADET_Channel *channel)
320 {
321  struct BobServiceSession *s = cls;
322 
324  "Peer disconnected, terminating session %s with peer %s\n",
325  GNUNET_h2s (&s->session_id),
326  GNUNET_i2s (&s->peer));
327  s->channel = NULL;
329  {
332  }
334 }
335 
336 
341 static void
342 bob_cadet_done_cb (void *cls)
343 {
344  struct BobServiceSession *session = cls;
345 
348 }
349 
350 
356 static void
358 {
360  struct GNUNET_MQ_Envelope *e;
361 
363  "Sending response to Alice\n");
364  e = GNUNET_MQ_msg (msg,
366  msg->contained_element_count = htonl (2);
367  if (NULL != s->prod_g_i_b_i)
369  s->prod_g_i_b_i,
370  &msg->prod_g_i_b_i);
371  if (NULL != s->prod_h_i_b_i)
373  s->prod_h_i_b_i,
374  &msg->prod_h_i_b_i);
377  s);
379  e);
380 }
381 
382 
392 static int
393 copy_element_cb (void *cls,
394  const struct GNUNET_HashCode *key,
395  void *value)
396 {
397  struct BobServiceSession *s = cls;
399  gcry_mpi_t mval;
400  int64_t val;
401 
402  mval = gcry_mpi_new (0);
403  val = (int64_t) GNUNET_ntohll (e->value);
404  if (0 > val)
405  gcry_mpi_sub_ui (mval, mval, -val);
406  else
407  gcry_mpi_add_ui (mval, mval, val);
410  s->used_element_count++;
411  return GNUNET_OK;
412 }
413 
414 
423 static int
424 element_cmp (const void *a,
425  const void *b)
426 {
427  const struct MpiElement *ma = a;
428  const struct MpiElement *mb = b;
429 
430  return GNUNET_CRYPTO_hash_cmp (ma->key,
431  mb->key);
432 }
433 
434 
444 static int
446  const struct EccAliceCryptodataMessage *msg)
447 {
448  struct BobServiceSession *s = cls;
449  uint32_t contained_elements;
450  size_t msg_length;
451  uint16_t msize;
452  unsigned int max;
453 
454  msize = ntohs (msg->header.size);
455  if (msize <= sizeof(struct EccAliceCryptodataMessage))
456  {
457  GNUNET_break_op (0);
458  return GNUNET_SYSERR;
459  }
460  contained_elements = ntohl (msg->contained_element_count);
461  /* Our intersection may still be ongoing, but this is nevertheless
462  an upper bound on the required array size */
464  msg_length = sizeof(struct EccAliceCryptodataMessage)
465  + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
466  if ((msize != msg_length) ||
467  (0 == contained_elements) ||
468  (contained_elements > UINT16_MAX) ||
469  (max < contained_elements + s->cadet_received_element_count))
470  {
471  GNUNET_break_op (0);
472  return GNUNET_SYSERR;
473  }
474  return GNUNET_OK;
475 }
476 
477 
485 static void
487  const struct EccAliceCryptodataMessage *msg)
488 {
489  struct BobServiceSession *s = cls;
490  const struct GNUNET_CRYPTO_EccPoint *payload;
491  uint32_t contained_elements;
492  unsigned int max;
493  unsigned int i;
494  const struct MpiElement *b_i;
495  gcry_mpi_point_t tmp;
496  gcry_mpi_point_t g_i;
497  gcry_mpi_point_t h_i;
498  gcry_mpi_point_t g_i_b_i;
499  gcry_mpi_point_t h_i_b_i;
500 
501  contained_elements = ntohl (msg->contained_element_count);
503  /* sort our vector for the computation */
504  if (NULL == s->sorted_elements)
505  {
506  s->sorted_elements
509  struct MpiElement);
510  s->used_element_count = 0;
513  s);
514  qsort (s->sorted_elements,
516  sizeof(struct MpiElement),
517  &element_cmp);
518  }
519 
521  "Received %u crypto values from Alice\n",
522  (unsigned int) contained_elements);
523  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
524 
525  for (i = 0; i < contained_elements; i++)
526  {
529  &payload[i * 2]);
530  g_i_b_i = GNUNET_CRYPTO_ecc_pmul_mpi (edc,
531  g_i,
532  b_i->value);
533  gcry_mpi_point_release (g_i);
535  &payload[i * 2 + 1]);
536  h_i_b_i = GNUNET_CRYPTO_ecc_pmul_mpi (edc,
537  h_i,
538  b_i->value);
539  gcry_mpi_point_release (h_i);
540  if (0 == i + s->cadet_received_element_count)
541  {
542  /* first iteration, nothing to add */
543  s->prod_g_i_b_i = g_i_b_i;
544  s->prod_h_i_b_i = h_i_b_i;
545  }
546  else
547  {
548  /* further iterations, cummulate resulting value */
549  tmp = GNUNET_CRYPTO_ecc_add (edc,
550  s->prod_g_i_b_i,
551  g_i_b_i);
552  gcry_mpi_point_release (s->prod_g_i_b_i);
553  gcry_mpi_point_release (g_i_b_i);
554  s->prod_g_i_b_i = tmp;
555  tmp = GNUNET_CRYPTO_ecc_add (edc,
556  s->prod_h_i_b_i,
557  h_i_b_i);
558  gcry_mpi_point_release (s->prod_h_i_b_i);
559  gcry_mpi_point_release (h_i_b_i);
560  s->prod_h_i_b_i = tmp;
561  }
562  }
563  s->cadet_received_element_count += contained_elements;
564  if ((s->cadet_received_element_count == max) &&
565  (NULL == s->intersection_op))
566  {
567  /* intersection has finished also on our side, and
568  we got the full set, so we can proceed with the
569  CADET response(s) */
571  }
573 }
574 
575 
585 static void
587  const struct GNUNET_SET_Element *element,
588  uint64_t current_size,
590 {
591  struct BobServiceSession *s = cls;
592  struct GNUNET_SCALARPRODUCT_Element *se;
593 
594  switch (status)
595  {
597  /* this element has been removed from the set */
599  element->data);
600  GNUNET_assert (NULL != se);
602  "Removed element with key %s and value %lld\n",
603  GNUNET_h2s (&se->key),
604  (long long) GNUNET_ntohll (se->value));
608  element->data,
609  se));
610  GNUNET_free (se);
611  return;
612 
614  s->intersection_op = NULL;
615  GNUNET_break (NULL == s->intersection_set);
618  "Finished intersection, %d items remain\n",
622  {
623  /* CADET transmission from Alice is also already done,
624  start with our own reply */
626  }
627  return;
628 
630  /* unexpected for intersection */
631  GNUNET_break (0);
632  return;
633 
635  /* unhandled status code */
637  "Set intersection failed!\n");
638  s->intersection_op = NULL;
639  if (NULL != s->intersection_set)
640  {
642  s->intersection_set = NULL;
643  }
646  return;
647 
648  default:
649  GNUNET_break (0);
650  return;
651  }
652 }
653 
654 
661 static void
663 {
664  struct GNUNET_HashCode set_sid;
665 
667  sizeof(struct GNUNET_HashCode),
668  &set_sid);
670  "Got session with key %s and %u elements, starting intersection.\n",
671  GNUNET_h2s (&s->session_id),
672  (unsigned int) s->total);
673 
674  s->intersection_op
675  = GNUNET_SET_prepare (&s->peer,
676  &set_sid,
677  NULL,
679  (struct GNUNET_SET_Option[]) { { 0 } },
681  s);
682  if (GNUNET_OK !=
683  GNUNET_SET_commit (s->intersection_op,
684  s->intersection_set))
685  {
686  GNUNET_break (0);
689  return;
690  }
691  GNUNET_SET_destroy (s->intersection_set);
692  s->intersection_set = NULL;
693 }
694 
695 
702 static void
704  const struct EccServiceRequestMessage *msg)
705 {
706  struct BobServiceSession *s = cls;
707 
708  s->session_id = msg->session_id; // ??
710  {
712  "Alice ready, still waiting for Bob client data!\n");
713  return;
714  }
716  "Both ready, launching intersection!\n");
717  start_intersection (s);
718 }
719 
720 
731 static void *
734  const struct GNUNET_PeerIdentity *initiator)
735 {
736  struct BobServiceSession *s = cls;
737 
739  "New incoming channel from peer %s.\n",
740  GNUNET_i2s (initiator));
742  s->port = NULL;
743  s->peer = *initiator;
744  s->channel = channel;
746  return s;
747 }
748 
749 
757 static int
759  const struct
761  msg)
762 {
763  struct BobServiceSession *s = cls;
764  uint32_t contained_count;
765  uint16_t msize;
766 
767  msize = ntohs (msg->header.size);
768  contained_count = ntohl (msg->element_count_contained);
769  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
770  + contained_count * sizeof(struct
772  (0 == contained_count) ||
773  (UINT16_MAX < contained_count) ||
775  (s->total < s->client_received_element_count + contained_count))
776  {
777  GNUNET_break (0);
778  return GNUNET_SYSERR;
779  }
780  return GNUNET_OK;
781 }
782 
783 
791 static void
793  const struct
795  msg)
796 {
797  struct BobServiceSession *s = cls;
798  uint32_t contained_count;
799  const struct GNUNET_SCALARPRODUCT_Element *elements;
800  struct GNUNET_SET_Element set_elem;
801  struct GNUNET_SCALARPRODUCT_Element *elem;
802 
803  contained_count = ntohl (msg->element_count_contained);
804  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
805  for (uint32_t i = 0; i < contained_count; i++)
806  {
808  GNUNET_memcpy (elem,
809  &elements[i],
810  sizeof(struct GNUNET_SCALARPRODUCT_Element));
811  if (GNUNET_SYSERR ==
813  &elem->key,
814  elem,
816  {
817  GNUNET_break (0);
818  GNUNET_free (elem);
819  continue;
820  }
821  set_elem.data = &elem->key;
822  set_elem.size = sizeof(elem->key);
823  set_elem.element_type = 0;
825  &set_elem,
826  NULL, NULL);
827  }
828  s->client_received_element_count += contained_count;
831  {
832  /* more to come */
834  "Request still partial, waiting for more client data!\n");
835  return;
836  }
837  if (NULL == s->channel)
838  {
839  /* no Alice waiting for this request, wait for Alice */
841  "Client ready, still waiting for Alice!\n");
842  return;
843  }
845  "Both ready, launching intersection!\n");
846  start_intersection (s);
847 }
848 
849 
858 static int
860  const struct BobComputationMessage *msg)
861 {
862  struct BobServiceSession *s = cls;
863  uint32_t contained_count;
864  uint32_t total_count;
865  uint16_t msize;
866 
868  {
869  GNUNET_break (0);
870  return GNUNET_SYSERR;
871  }
872  msize = ntohs (msg->header.size);
873  total_count = ntohl (msg->element_count_total);
874  contained_count = ntohl (msg->element_count_contained);
875  if ((0 == total_count) ||
876  (0 == contained_count) ||
877  (UINT16_MAX < contained_count) ||
878  (msize != (sizeof(struct BobComputationMessage)
879  + contained_count * sizeof(struct
881  {
882  GNUNET_break_op (0);
883  return GNUNET_SYSERR;
884  }
885  return GNUNET_OK;
886 }
887 
888 
897 static void
899  const struct BobComputationMessage *msg)
900 {
901  struct BobServiceSession *s = cls;
902  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
903  GNUNET_MQ_hd_fixed_size (alices_computation_request,
906  s),
907  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
910  s),
912  };
913  uint32_t contained_count;
914  uint32_t total_count;
915  const struct GNUNET_SCALARPRODUCT_Element *elements;
916  struct GNUNET_SET_Element set_elem;
917  struct GNUNET_SCALARPRODUCT_Element *elem;
918 
919  total_count = ntohl (msg->element_count_total);
920  contained_count = ntohl (msg->element_count_contained);
921 
923  s->total = total_count;
924  s->client_received_element_count = contained_count;
925  s->session_id = msg->session_key;
926  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
929  GNUNET_YES);
931  = GNUNET_SET_create (cfg,
933  for (uint32_t i = 0; i < contained_count; i++)
934  {
935  if (0 == GNUNET_ntohll (elements[i].value))
936  continue;
938  GNUNET_memcpy (elem,
939  &elements[i],
940  sizeof(struct GNUNET_SCALARPRODUCT_Element));
941  if (GNUNET_SYSERR ==
943  &elem->key,
944  elem,
946  {
947  GNUNET_break (0);
948  GNUNET_free (elem);
949  continue;
950  }
951  set_elem.data = &elem->key;
952  set_elem.size = sizeof(elem->key);
953  set_elem.element_type = 0;
955  &set_elem,
956  NULL, NULL);
957  s->used_element_count++;
958  }
961  "Received client request, opening port %s!\n",
962  GNUNET_h2s (&msg->session_key));
963  s->port = GNUNET_CADET_open_port (my_cadet,
964  &msg->session_key,
966  s,
967  NULL,
969  cadet_handlers);
970  if (NULL == s->port)
971  {
972  GNUNET_break (0);
974  return;
975  }
976 }
977 
978 
984 static void
985 shutdown_task (void *cls)
986 {
988  "Shutting down, initiating cleanup.\n");
989  // FIXME: we have to cut our connections to CADET first!
990  if (NULL != my_cadet)
991  {
992  GNUNET_CADET_disconnect (my_cadet);
993  my_cadet = NULL;
994  }
995  if (NULL != edc)
996  {
998  edc = NULL;
999  }
1000 }
1001 
1002 
1013 static void *
1015  struct GNUNET_SERVICE_Client *client,
1016  struct GNUNET_MQ_Handle *mq)
1017 {
1018  struct BobServiceSession *s;
1019 
1020  s = GNUNET_new (struct BobServiceSession);
1021  s->client = client;
1022  s->client_mq = mq;
1023  return s;
1024 }
1025 
1026 
1037 static void
1039  struct GNUNET_SERVICE_Client *client,
1040  void *app_cls)
1041 {
1042  struct BobServiceSession *s = app_cls;
1043 
1045  "Client disconnected from us.\n");
1046  s->client = NULL;
1048 }
1049 
1050 
1058 static void
1059 run (void *cls,
1060  const struct GNUNET_CONFIGURATION_Handle *c,
1062 {
1063  cfg = c;
1064  /* We don't really do DLOG, so we can setup with very minimal resources */
1065  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1066  2 /* RAM */);
1067  my_cadet = GNUNET_CADET_connect (cfg);
1069  NULL);
1070  if (NULL == my_cadet)
1071  {
1073  _ ("Connect to CADET failed\n"));
1075  return;
1076  }
1077 }
1078 
1079 
1084  ("scalarproduct-bob",
1086  &run,
1089  NULL,
1090  GNUNET_MQ_hd_var_size (bob_client_message,
1092  struct BobComputationMessage,
1093  NULL),
1094  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
1097  NULL),
1099 
1100 
1101 /* end of gnunet-service-scalarproduct-ecc_bob.c */
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
The product of the g_i^{b_i} values.
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
int in_destroy
Are we already in destroy_service_session()?
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:841
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
static int check_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
static void handle_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob&#39;s a client request message.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
gcry_mpi_point_t GNUNET_CRYPTO_ecc_bin_to_point(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *bin)
Convert binary representation of a point to computational representation.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
gcry_mpi_point_t prod_g_i_b_i
Product of the g_i^{b_i}.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
int GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
Add an element to the given set.
Definition: set_api.c:687
static void handle_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us...
Opaque handle to the service.
Definition: cadet_api.c:38
uint32_t used_element_count
How many elements actually are used for the scalar product.
Handle to a service.
Definition: service.c:116
scalarproduct service P2P messages
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:99
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB.
Definition: scalarproduct.h:94
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
Operation is still active (never returned, used internally).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Element stored in a set.
struct GNUNET_SET_Handle * GNUNET_SET_create(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op)
Create an empty set, supporting the specified operation.
Definition: set_api.c:657
struct GNUNET_CADET_Port * port
Our open port.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob&#39;s end.
static int check_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob&#39;s a client request message.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
static struct Experiment * e
static struct GNUNET_HashCode session_id
Opaque handle to a channel.
Definition: cadet_api.c:80
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SET_OperationHandle * GNUNET_SET_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: set_api.c:813
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
Client -> Bob.
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
gcry_mpi_t value
a_i value, not disclosed to Bob.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
void GNUNET_CRYPTO_ecc_point_to_bin(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t point, struct GNUNET_CRYPTO_EccPoint *bin)
Convert point value to binary representation.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
Success, all elements have been sent (and received).
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const void * data
Actual data of the element.
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:976
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Handle to a client that is connected to a service.
Definition: service.c:250
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SET_Element *element, uint64_t current_size, enum GNUNET_SET_Status status)
Callback for set operation results.
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:772
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incomming MQ-based channels.
Definition: cadet_api.c:1010
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
The other peer refused to to the operation with us, or something went wrong.
Success, all elements have been returned (but the other peer might still be receiving some from us...
Scalar Product API Message Types.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
Everything went ok, we are transmitting an element of the result (in set, or to be removed from set...
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Operation is still active (never returned, used internally).
GNUNET_SET_Status
Status for the result callback.
struct GNUNET_CADET_Channel * channel
The CADET channel.
uint16_t status
See PRISM_STATUS_*-constants.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_add(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t a, gcry_mpi_point_t b)
Add two points on the elliptic curve.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
GNUNET_SERVICE_MAIN("scalarproduct-bob", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(bob_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, struct BobComputationMessage, NULL), GNUNET_MQ_hd_var_size(bob_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
The product of the h_i^{b_i} values.
uint32_t contained_element_count
How many elements this individual message delivers (in NBO), always TWO.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA.
A 512-bit hashcode.
uint32_t total
How many elements will be supplied in total from the client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
Message handler for a specific message type.
Opaque handle to a set.
Definition: set_api.c:49
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Message type passed from responding service Bob to responding service Alice to complete a request and...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
An encrypted element key-value pair.
static void handle_alices_computation_request(void *cls, const struct EccServiceRequestMessage *msg)
Handle a request from Alice to calculate a scalarproduct with us (Bob).
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
uint32_t product_length
0 if no product attached
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
Option for set operations.
int64_t value
Value to multiply in scalar product, in NBO.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
static int check_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Check a multipart-chunk of a request from another service to calculate a scalarproduct with us...
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static unsigned long long payload
How much data are we currently storing in the database?
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
uint32_t element_count_contained
contained elements the vector in payload contains
Handle to an operation.
Definition: set_api.c:135
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
static void handle_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
The identity of the host (wraps the signing key of the peer).
int GNUNET_SET_commit(struct GNUNET_SET_OperationHandle *oh, struct GNUNET_SET_Handle *set)
Commit a set to be used with a set operation.
Definition: set_api.c:1128
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:954
struct GNUNET_MessageHeader header
GNUNET message header.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
configuration data
Definition: configuration.c:85
static int copy_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to copy over messages from the hash map into an array for sorting.
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:294
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB
Client -> Bob multipart.
Opaque handle to a port.
Definition: cadet_api.c:145
Client gets only elements that have been removed from the set.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
uint32_t element_count_contained
contained elements the vector in payload contains
void GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh)
Cancel the given set operation.
Definition: set_api.c:516
multipart messages following struct ComputationMessage
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:88
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
Internal structure used to cache pre-calculated values for DLOG calculation.
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:874
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
Set intersection, only return elements that are in both sets.
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
static void shutdown_task(void *cls)
Task run during shutdown.
#define LOG(kind,...)
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
gcry_mpi_point_t GNUNET_CRYPTO_ecc_pmul_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t p, gcry_mpi_t val)
Multiply the point p on the elliptic curve by val.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
gcry_mpi_point_t prod_h_i_b_i
Product of the h_i^{b_i}.
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t element_type
Application-specific element type.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1119