GNUnet  0.11.x
gnunet-service-scalarproduct_bob.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013, 2014, 2016 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_seti_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 
65 struct BobServiceSession
66 {
71 
76 
81 
86 
92 
98 
102  struct GNUNET_CADET_Port *port;
103 
107  struct MpiElement *sorted_elements;
108 
113 
118 
123 
128 
133 
138  struct CadetIncomingSession *cadet;
139 
143  uint32_t total;
144 
150 
156  uint32_t used_element_count;
157 
163 
169 
177 
181  int in_destroy;
182 
187 
191  struct GNUNET_PeerIdentity peer;
192 
197 
201  struct GNUNET_MQ_Handle *cadet_mq;
202 };
203 
204 
208 static const struct GNUNET_CONFIGURATION_Handle *cfg;
209 
214 
219 
223 static gcry_mpi_t my_offset;
224 
229 
230 
238 static int
239 free_element_cb (void *cls,
240  const struct GNUNET_HashCode *key,
241  void *value)
242 {
243  struct GNUNET_SCALARPRODUCT_Element *element = value;
244 
245  GNUNET_free (element);
246  return GNUNET_OK;
247 }
248 
249 
255 static void
257 {
258  unsigned int i;
259 
260  if (GNUNET_YES == s->in_destroy)
261  return;
262  s->in_destroy = GNUNET_YES;
263  if (NULL != s->client)
264  {
265  struct GNUNET_SERVICE_Client *c = s->client;
266 
267  s->client = NULL;
269  }
270  if (NULL != s->intersected_elements)
271  {
274  NULL);
276  s->intersected_elements = NULL;
277  }
278  if (NULL != s->intersection_op)
279  {
281  s->intersection_op = NULL;
282  }
283  if (NULL != s->intersection_set)
284  {
286  s->intersection_set = NULL;
287  }
288  if (NULL != s->e_a)
289  {
290  GNUNET_free (s->e_a);
291  s->e_a = NULL;
292  }
293  if (NULL != s->sorted_elements)
294  {
295  for (i = 0; i < s->used_element_count; i++)
296  gcry_mpi_release (s->sorted_elements[i].value);
298  s->sorted_elements = NULL;
299  }
300  if (NULL != s->r)
301  {
302  GNUNET_free (s->r);
303  s->r = NULL;
304  }
305  if (NULL != s->r_prime)
306  {
307  GNUNET_free (s->r_prime);
308  s->r_prime = NULL;
309  }
310  if (NULL != s->port)
311  {
313  s->port = NULL;
314  }
315  if (NULL != s->channel)
316  {
318  s->channel = NULL;
319  }
320  GNUNET_free (s);
321 }
322 
323 
331 static void
333 {
334  struct ClientResponseMessage *msg;
335  struct GNUNET_MQ_Envelope *e;
336 
337  if (NULL == session->client_mq)
338  return; /* no client left to be notified */
340  "Sending session-end notification with status %d to client for session %s\n",
341  session->status,
342  GNUNET_h2s (&session->session_id));
343  e = GNUNET_MQ_msg (msg,
345  msg->range = 0;
346  msg->product_length = htonl (0);
347  msg->status = htonl (session->status);
348  GNUNET_MQ_send (session->client_mq,
349  e);
350 }
351 
352 
362 static void
364  const struct GNUNET_CADET_Channel *channel)
365 {
366  struct BobServiceSession *s = cls;
367 
369  "Peer disconnected, terminating session %s with peer %s\n",
370  GNUNET_h2s (&s->session_id),
371  GNUNET_i2s (&s->peer));
372  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
373  {
376  }
377  s->channel = NULL;
379 }
380 
381 
386 static void
387 bob_cadet_done_cb (void *cls)
388 {
389  struct BobServiceSession *session = cls;
390 
393 }
394 
395 
399 #define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
400  - sizeof(struct BobCryptodataMultipartMessage)) \
401  / sizeof(struct \
402  GNUNET_CRYPTO_PaillierCiphertext))
403 
404 
411 static void
413 {
416  struct GNUNET_MQ_Envelope *e;
417  unsigned int i;
418  unsigned int j;
419  uint32_t todo_count;
420 
422  {
424  if (todo_count > ELEMENT_CAPACITY / 2)
425  todo_count = ELEMENT_CAPACITY / 2;
426 
428  "Sending %u additional crypto values to Alice\n",
429  (unsigned int) todo_count);
431  todo_count * sizeof(struct
433  * 2,
435  msg->contained_element_count = htonl (todo_count);
437  for (i = s->cadet_transmitted_element_count, j = 0; i <
438  s->cadet_transmitted_element_count + todo_count; i++)
439  {
440  // r[i][p] and r[i][q]
441  GNUNET_memcpy (&payload[j++],
442  &s->r[i],
443  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
444  GNUNET_memcpy (&payload[j++],
445  &s->r_prime[i],
446  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
447  }
448  s->cadet_transmitted_element_count += todo_count;
452  s);
454  e);
455  }
457  "All values queued for Alice, Bob is done\n");
458 }
459 
460 
472 static void
474 {
475  struct BobCryptodataMessage *msg;
476  struct GNUNET_MQ_Envelope *e;
478  unsigned int i;
479 
481  = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct
483  / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
486 
489  * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
491  msg->contained_element_count = htonl (s->cadet_transmitted_element_count);
492 
494  "Sending %u/%u crypto values to Alice\n",
495  (unsigned int) s->cadet_transmitted_element_count,
496  (unsigned int) s->used_element_count);
497 
499  GNUNET_memcpy (&payload[0],
500  &s->s,
501  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
502  GNUNET_memcpy (&payload[1],
503  &s->s_prime,
504  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
505 
506  payload = &payload[2];
507  // convert k[][]
508  for (i = 0; i < s->cadet_transmitted_element_count; i++)
509  {
510  // k[i][p] and k[i][q]
511  GNUNET_memcpy (&payload[i * 2],
512  &s->r[i],
513  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
514  GNUNET_memcpy (&payload[i * 2 + 1],
515  &s->r_prime[i],
516  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
517  }
521  s);
523  e);
525 }
526 
527 
528 #undef ELEMENT_CAPACITY
529 
530 
539 static gcry_mpi_t
540 compute_square_sum (const gcry_mpi_t *vector,
541  uint32_t length)
542 {
543  gcry_mpi_t elem;
544  gcry_mpi_t sum;
545  uint32_t i;
546 
547  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
548  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
549  for (i = 0; i < length; i++)
550  {
551  gcry_mpi_mul (elem, vector[i], vector[i]);
552  gcry_mpi_add (sum, sum, elem);
553  }
554  gcry_mpi_release (elem);
555  return sum;
556 }
557 
558 
569 static int
571 {
572  uint32_t i;
573  unsigned int *p;
574  unsigned int *q;
575  uint32_t count;
576  gcry_mpi_t *rand;
577  gcry_mpi_t tmp;
578  const struct MpiElement *b;
581  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
582 
583  count = session->used_element_count;
584  a = session->e_a;
585  b = session->sorted_elements;
587  count);
589  count);
590  rand = GNUNET_malloc (sizeof(gcry_mpi_t) * count);
591  for (i = 0; i < count; i++)
592  GNUNET_assert (NULL != (rand[i] = gcry_mpi_new (0)));
593  r = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
594  r_prime = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
595  * count);
596 
597  for (i = 0; i < count; i++)
598  {
599  int32_t svalue;
600 
602  UINT32_MAX);
603  // long to gcry_mpi_t
604  if (svalue < 0)
605  gcry_mpi_sub_ui (rand[i],
606  rand[i],
607  -svalue);
608  else
609  rand[i] = gcry_mpi_set_ui (rand[i], svalue);
610  }
611 
612  tmp = gcry_mpi_new (0);
613  // encrypt the element
614  // for the sake of readability I decided to have dedicated permutation
615  // vectors, which get rid of all the lookups in p/q.
616  // however, ap/aq are not absolutely necessary but are just abstraction
617  // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
618  for (i = 0; i < count; i++)
619  {
620  // E(S - r_pi - b_pi)
621  gcry_mpi_sub (tmp, my_offset, rand[p[i]]);
622  gcry_mpi_sub (tmp, tmp, b[p[i]].value);
623  GNUNET_assert (2 ==
625  tmp,
626  2,
627  &r[i]));
628 
629  // E(S - r_pi - b_pi) * E(S + a_pi) == E(2*S + a - r - b)
630  if (GNUNET_OK !=
632  &r[i],
633  &a[p[i]],
634  &r[i]))
635  {
636  GNUNET_break_op (0);
637  goto error_cleanup;
638  }
639  }
640 
641  // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
642  for (i = 0; i < count; i++)
643  {
644  // E(S - r_qi)
645  gcry_mpi_sub (tmp, my_offset, rand[q[i]]);
646  GNUNET_assert (2 ==
648  tmp,
649  2,
650  &r_prime[i]));
651 
652  // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
653  if (GNUNET_OK !=
655  &r_prime[i],
656  &a[q[i]],
657  &r_prime[i]))
658  {
659  GNUNET_break_op (0);
660  goto error_cleanup;
661  }
662  }
663  gcry_mpi_release (tmp);
664 
665  // Calculate S' = E(SUM( r_i^2 ))
666  tmp = compute_square_sum (rand, count);
667  GNUNET_assert (1 ==
669  tmp,
670  1,
671  &session->s_prime));
672  gcry_mpi_release (tmp);
673 
674  // Calculate S = E(SUM( (r_i + b_i)^2 ))
675  for (i = 0; i < count; i++)
676  gcry_mpi_add (rand[i], rand[i], b[i].value);
677  tmp = compute_square_sum (rand, count);
678  GNUNET_assert (1 ==
680  tmp,
681  1,
682  &session->s));
683  gcry_mpi_release (tmp);
684 
685  session->r = r;
686  session->r_prime = r_prime;
687 
688  for (i = 0; i < count; i++)
689  gcry_mpi_release (rand[i]);
690  GNUNET_free (session->e_a);
691  session->e_a = NULL;
692  GNUNET_free (p);
693  GNUNET_free (q);
694  GNUNET_free (rand);
695  return GNUNET_OK;
696 
697 error_cleanup:
698  GNUNET_free (r);
699  GNUNET_free (r_prime);
700  gcry_mpi_release (tmp);
701  GNUNET_free (p);
702  GNUNET_free (q);
703  for (i = 0; i < count; i++)
704  gcry_mpi_release (rand[i]);
705  GNUNET_free (rand);
706  return GNUNET_SYSERR;
707 }
708 
709 
719 static int
720 copy_element_cb (void *cls,
721  const struct GNUNET_HashCode *key,
722  void *value)
723 {
724  struct BobServiceSession *s = cls;
726  gcry_mpi_t mval;
727  int64_t val;
728 
729  mval = gcry_mpi_new (0);
730  val = (int64_t) GNUNET_ntohll (e->value);
731  if (0 > val)
732  gcry_mpi_sub_ui (mval, mval, -val);
733  else
734  gcry_mpi_add_ui (mval, mval, val);
736  s->sorted_elements [s->used_element_count].key = &e->key;
737  s->used_element_count++;
738  return GNUNET_OK;
739 }
740 
741 
750 static int
751 element_cmp (const void *a,
752  const void *b)
753 {
754  const struct MpiElement *ma = a;
755  const struct MpiElement *mb = b;
756 
757  return GNUNET_CRYPTO_hash_cmp (ma->key,
758  mb->key);
759 }
760 
761 
769 static void
771 {
772  struct GNUNET_CADET_Channel *channel;
773 
774  /* TODO: code duplication with Alice! */
776  "Received everything, building reply for Alice\n");
777  s->sorted_elements
780  * sizeof(struct MpiElement));
781  s->used_element_count = 0;
784  s);
785  qsort (s->sorted_elements,
787  sizeof(struct MpiElement),
788  &element_cmp);
789  if (GNUNET_OK !=
791  {
792  channel = s->channel;
793  s->channel = NULL;
795  return;
796  }
798 }
799 
800 
810 static int
812  const struct AliceCryptodataMessage *msg)
813 {
814  struct BobServiceSession *s = cls;
815  uint32_t contained_elements;
816  size_t msg_length;
817  uint16_t msize;
818  unsigned int max;
819 
820  msize = ntohs (msg->header.size);
821  contained_elements = ntohl (msg->contained_element_count);
822  /* Our intersection may still be ongoing, but this is nevertheless
823  an upper bound on the required array size */
824  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
825  msg_length = sizeof(struct AliceCryptodataMessage)
826  + contained_elements * sizeof(struct
828  if ((msize != msg_length) ||
829  (0 == contained_elements) ||
830  (contained_elements > UINT16_MAX) ||
831  (max < contained_elements + s->cadet_received_element_count))
832  {
833  GNUNET_break_op (0);
834  return GNUNET_SYSERR;
835  }
836  return GNUNET_OK;
837 }
838 
839 
847 static void
849  const struct AliceCryptodataMessage *msg)
850 {
851  struct BobServiceSession *s = cls;
853  uint32_t contained_elements;
854  unsigned int max;
855 
856  contained_elements = ntohl (msg->contained_element_count);
857  /* Our intersection may still be ongoing, but this is nevertheless
858  an upper bound on the required array size */
861  "Received %u crypto values from Alice\n",
862  (unsigned int) contained_elements);
863 
864  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
865  if (NULL == s->e_a)
866  s->e_a = GNUNET_new_array (max,
869  payload,
870  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
871  * contained_elements);
872  s->cadet_received_element_count += contained_elements;
873 
874  if ((s->cadet_received_element_count == max) &&
875  (NULL == s->intersection_op))
876  {
877  /* intersection has finished also on our side, and
878  we got the full set, so we can proceed with the
879  CADET response(s) */
881  }
883 }
884 
885 
895 static void
897  const struct GNUNET_SETI_Element *element,
898  uint64_t current_size,
900 {
901  struct BobServiceSession *s = cls;
902  struct GNUNET_SCALARPRODUCT_Element *se;
903 
904  switch (status)
905  {
907  /* this element has been removed from the set */
909  element->data);
910  GNUNET_assert (NULL != se);
912  "Removed element with key %s and value %lld\n",
913  GNUNET_h2s (&se->key),
914  (long long) GNUNET_ntohll (se->value));
918  element->data,
919  se));
920  GNUNET_free (se);
921  return;
923  s->intersection_op = NULL;
924  GNUNET_break (NULL == s->intersection_set);
927  "Finished intersection, %d items remain\n",
931  {
932  /* CADET transmission from Alice is also already done,
933  start with our own reply */
935  }
936  return;
938  /* unhandled status code */
940  "Set intersection failed!\n");
941  s->intersection_op = NULL;
942  if (NULL != s->intersection_set)
943  {
945  s->intersection_set = NULL;
946  }
949  return;
950  default:
951  GNUNET_break (0);
952  return;
953  }
954 }
955 
956 
963 static void
965 {
967  "Got session with key %s and %u elements, starting intersection.\n",
968  GNUNET_h2s (&s->session_id),
969  (unsigned int) s->total);
970 
971  s->intersection_op
972  = GNUNET_SETI_prepare (&s->peer,
973  &s->session_id,
974  NULL,
975  (struct GNUNET_SETI_Option[]) { { 0 } },
977  s);
978  if (GNUNET_OK !=
979  GNUNET_SETI_commit (s->intersection_op,
980  s->intersection_set))
981  {
982  GNUNET_break (0);
985  return;
986  }
987  GNUNET_SETI_destroy (s->intersection_set);
988  s->intersection_set = NULL;
989 }
990 
991 
998 static void
1000  const struct ServiceRequestMessage *msg)
1001 {
1002  struct BobServiceSession *s = cls;
1003 
1004  s->session_id = msg->session_id; // ??
1005  s->remote_pubkey = msg->public_key;
1006  if (s->client_received_element_count == s->total)
1008 }
1009 
1010 
1021 static void *
1023  struct GNUNET_CADET_Channel *channel,
1024  const struct GNUNET_PeerIdentity *initiator)
1025 {
1026  struct BobServiceSession *s = cls;
1027 
1029  "New incoming channel from peer %s.\n",
1030  GNUNET_i2s (initiator));
1031  GNUNET_CADET_close_port (s->port);
1032  s->port = NULL;
1033  s->channel = channel;
1034  s->peer = *initiator;
1035  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
1036  return s;
1037 }
1038 
1039 
1047 static int
1049  const struct
1051  msg)
1052 {
1053  struct BobServiceSession *s = cls;
1054  uint32_t contained_count;
1055  uint16_t msize;
1056 
1057  msize = ntohs (msg->header.size);
1058  contained_count = ntohl (msg->element_count_contained);
1059  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
1060  + contained_count * sizeof(struct
1062  (0 == contained_count) ||
1063  (UINT16_MAX < contained_count) ||
1064  (s->total == s->client_received_element_count) ||
1065  (s->total < s->client_received_element_count + contained_count))
1066  {
1067  GNUNET_break (0);
1068  return GNUNET_SYSERR;
1069  }
1070  return GNUNET_OK;
1071 }
1072 
1073 
1081 static void
1083  const struct
1085  msg)
1086 {
1087  struct BobServiceSession *s = cls;
1088  uint32_t contained_count;
1089  const struct GNUNET_SCALARPRODUCT_Element *elements;
1090  struct GNUNET_SETI_Element set_elem;
1091  struct GNUNET_SCALARPRODUCT_Element *elem;
1092 
1093  contained_count = ntohl (msg->element_count_contained);
1094  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1095  for (uint32_t i = 0; i < contained_count; i++)
1096  {
1097  elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
1098  GNUNET_memcpy (elem,
1099  &elements[i],
1100  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1101  if (GNUNET_SYSERR ==
1103  &elem->key,
1104  elem,
1106  {
1107  GNUNET_break (0);
1108  GNUNET_free (elem);
1109  continue;
1110  }
1111  set_elem.data = &elem->key;
1112  set_elem.size = sizeof(elem->key);
1113  set_elem.element_type = 0;
1115  &set_elem,
1116  NULL, NULL);
1117  }
1118  s->client_received_element_count += contained_count;
1120  if (s->total != s->client_received_element_count)
1121  {
1122  /* more to come */
1123  return;
1124  }
1125  if (NULL == s->channel)
1126  {
1127  /* no Alice waiting for this request, wait for Alice */
1128  return;
1129  }
1130  start_intersection (s);
1131 }
1132 
1133 
1142 static int
1144  const struct BobComputationMessage *msg)
1145 {
1146  struct BobServiceSession *s = cls;
1147  uint32_t contained_count;
1148  uint32_t total_count;
1149  uint16_t msize;
1150 
1151  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
1152  {
1153  GNUNET_break (0);
1154  return GNUNET_SYSERR;
1155  }
1156  msize = ntohs (msg->header.size);
1157  total_count = ntohl (msg->element_count_total);
1158  contained_count = ntohl (msg->element_count_contained);
1159  if ((0 == total_count) ||
1160  (0 == contained_count) ||
1161  (UINT16_MAX < contained_count) ||
1162  (msize != (sizeof(struct BobComputationMessage)
1163  + contained_count * sizeof(struct
1165  {
1166  GNUNET_break_op (0);
1167  return GNUNET_SYSERR;
1168  }
1169  return GNUNET_OK;
1170 }
1171 
1172 
1181 static void
1183  const struct BobComputationMessage *msg)
1184 {
1185  struct BobServiceSession *s = cls;
1186  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
1187  GNUNET_MQ_hd_fixed_size (alices_computation_request,
1189  struct ServiceRequestMessage,
1190  NULL),
1191  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
1193  struct AliceCryptodataMessage,
1194  NULL),
1196  };
1197  uint32_t contained_count;
1198  uint32_t total_count;
1199  const struct GNUNET_SCALARPRODUCT_Element *elements;
1200  struct GNUNET_SETI_Element set_elem;
1201  struct GNUNET_SCALARPRODUCT_Element *elem;
1202 
1203  total_count = ntohl (msg->element_count_total);
1204  contained_count = ntohl (msg->element_count_contained);
1205 
1207  s->total = total_count;
1208  s->client_received_element_count = contained_count;
1209  s->session_id = msg->session_key;
1210  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1213  GNUNET_YES);
1215  for (uint32_t i = 0; i < contained_count; i++)
1216  {
1217  if (0 == GNUNET_ntohll (elements[i].value))
1218  continue;
1219  elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
1220  GNUNET_memcpy (elem,
1221  &elements[i],
1222  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1223  if (GNUNET_SYSERR ==
1225  &elem->key,
1226  elem,
1228  {
1229  GNUNET_break (0);
1230  GNUNET_free (elem);
1231  continue;
1232  }
1233  set_elem.data = &elem->key;
1234  set_elem.size = sizeof(elem->key);
1235  set_elem.element_type = 0;
1237  &set_elem,
1238  NULL, NULL);
1239  s->used_element_count++;
1240  }
1242  /* We're ready, open the port */
1244  &msg->session_key,
1246  s,
1247  NULL,
1249  cadet_handlers);
1250  if (NULL == s->port)
1251  {
1252  GNUNET_break (0);
1254  return;
1255  }
1256 }
1257 
1258 
1264 static void
1265 shutdown_task (void *cls)
1266 {
1268  "Shutting down, initiating cleanup.\n");
1269  // FIXME: we have to cut our connections to CADET first!
1270  if (NULL != my_cadet)
1271  {
1273  my_cadet = NULL;
1274  }
1275 }
1276 
1277 
1288 static void *
1290  struct GNUNET_SERVICE_Client *client,
1291  struct GNUNET_MQ_Handle *mq)
1292 {
1293  struct BobServiceSession *s;
1294 
1295  s = GNUNET_new (struct BobServiceSession);
1296  s->client = client;
1297  s->client_mq = mq;
1298  return s;
1299 }
1300 
1301 
1312 static void
1314  struct GNUNET_SERVICE_Client *client,
1315  void *app_cls)
1316 {
1317  struct BobServiceSession *s = app_cls;
1318 
1320  "Client disconnected from us.\n");
1321  s->client = NULL;
1323 }
1324 
1325 
1333 static void
1334 run (void *cls,
1335  const struct GNUNET_CONFIGURATION_Handle *c,
1337 {
1338  cfg = c;
1339  /*
1340  offset has to be sufficiently small to allow computation of:
1341  m1+m2 mod n == (S + a) + (S + b) mod n,
1342  if we have more complex operations, this factor needs to be lowered */
1343  my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
1344  gcry_mpi_set_bit (my_offset,
1346 
1348  &my_privkey);
1351  NULL);
1352  if (NULL == my_cadet)
1353  {
1355  _ ("Connect to CADET failed\n"));
1357  return;
1358  }
1359 }
1360 
1361 
1366  ("scalarproduct-bob",
1368  &run,
1371  NULL,
1372  GNUNET_MQ_hd_var_size (bob_client_message,
1374  struct BobComputationMessage,
1375  NULL),
1376  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
1379  NULL),
1381 
1382 
1383 /* end of gnunet-service-scalarproduct_bob.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct Experiment * e
struct GNUNET_HashCode key
The key used in the DHT.
uint16_t status
See PRISM_STATUS_*-constants.
static char * value
Value of the record to add/remove.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static unsigned long long payload
How much data are we currently storing in the database?
scalarproduct service P2P messages
static void handle_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
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.
static void start_intersection(struct BobServiceSession *s)
We've paired up a client session with an incoming CADET request.
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
Service's own private key.
static void handle_alices_cryptodata_message(void *cls, const struct AliceCryptodataMessage *msg)
Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static int check_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice after computing the values (1),...
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob's end.
#define ELEMENT_CAPACITY
Maximum count of elements we can put into a multipart message.
static void shutdown_task(void *cls)
Task run during shutdown.
static int check_alices_cryptodata_message(void *cls, const struct AliceCryptodataMessage *msg)
Check a multipart-chunk of a request from another service to calculate a scalarproduct with us.
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
static void handle_alices_computation_request(void *cls, const struct ServiceRequestMessage *msg)
Handle a request from Alice to calculate a scalarproduct with us (Bob).
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
static void handle_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob's a client request message.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
static int compute_service_response(struct BobServiceSession *session)
Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{p...
static int check_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob's a client request message.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
static gcry_mpi_t compute_square_sum(const gcry_mpi_t *vector, uint32_t length)
Computes the square sum over a vector of a given length.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
#define LOG(kind,...)
static void transmit_cryptographic_reply(struct BobServiceSession *s)
Intersection operation and receiving data via CADET from Alice are both done, compute and transmit ou...
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.
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
Callback for set operation results.
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
Service's own public key.
static gcry_mpi_t my_offset
Service's offset for values that could possibly be negative but are plaintext for encryption.
static void transmit_bobs_cryptodata_message_multipart(struct BobServiceSession *s)
Send a multipart chunk of a service response from Bob to Alice.
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
int GNUNET_CRYPTO_paillier_encrypt(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const gcry_mpi_t m, int desired_ops, struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
Encrypt a plaintext with a paillier public key.
void GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
Create a freshly generated paillier public key.
int GNUNET_CRYPTO_paillier_hom_add(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *c1, const struct GNUNET_CRYPTO_PaillierCiphertext *c2, struct GNUNET_CRYPTO_PaillierCiphertext *result)
Compute a ciphertext that represents the sum of the plaintext in x1 and x2.
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:888
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:775
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:808
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:1082
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:910
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 incoming MQ-based channels.
Definition: cadet_api.c:970
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
unsigned int * GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
Get an array with a random permutation of the numbers 0...n-1.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
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:201
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:52
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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:787
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
Alice -> Bob SP crypto-data (after intersection)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA
Bob -> Alice SP crypto-data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
Client -> Bob.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB
Client -> Bob multipart.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
Alice -> Bob session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART
Bob -> Alice SP crypto-data multipart.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
@ GNUNET_SCALARPRODUCT_STATUS_INIT
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.
@ GNUNET_SCALARPRODUCT_STATUS_ACTIVE
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_FAILURE
We encountered some error.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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,...
Definition: scheduler.c:1331
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
GNUNET_SETI_Status
Status for the result callback.
void GNUNET_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: seti_api.c:488
struct GNUNET_SETI_Handle * GNUNET_SETI_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create an empty set, supporting the specified operation.
Definition: seti_api.c:399
int GNUNET_SETI_add_element(struct GNUNET_SETI_Handle *set, const struct GNUNET_SETI_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Add an element to the given set.
Definition: seti_api.c:447
int GNUNET_SETI_commit(struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
Commit a set to be used with a set operation.
Definition: seti_api.c:836
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: seti_api.c:526
@ GNUNET_SETI_STATUS_DONE
Success, all elements have been sent (and received).
@ GNUNET_SETI_STATUS_FAILURE
The other peer refused to do the operation with us, or something went wrong.
@ GNUNET_SETI_STATUS_DEL_LOCAL
Element should be delete from the result set of the local peer, i.e.
#define max(x, y)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Scalar Product API Message Types.
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection).
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:89
Message type passed from responding service Bob to responding service Alice to complete a request and...
Multipart Message type passed between to supply additional elements for the peer.
A scalarproduct session which tracks an offer for a multiplication service by a local client.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob's permutation q of R.
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob's "s'".
uint32_t total
How many elements will be supplied in total from the client.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value'd elements transmitted to us.
uint32_t cadet_transmitted_element_count
Counts the number of values transmitted from us to Alice.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct CadetIncomingSession * cadet
Handle for our associated incoming CADET session, or NULL if we have not gotten one yet.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CRYPTO_PaillierCiphertext * e_a
E(ai)(Bob) after applying the mask.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob's permutation p of R.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CRYPTO_PaillierPublicKey remote_pubkey
Public key of the remote service.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
int in_destroy
Are we already in destroy_service_session()?
struct GNUNET_PeerIdentity peer
Originator's peer identity.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
Message type passed from service client to finalize a session as requester or responder.
multipart messages following struct ComputationMessage
Opaque handle to a channel.
Definition: cadet.h:117
Opaque handle to the service.
Definition: cadet_api.c:39
Opaque handle to a port.
Definition: cadet_api.c:80
Internal representation of the hash map.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
An element key-value pair for scalarproduct.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
int64_t value
Value to multiply in scalar product, in NBO.
Handle to a client that is connected to a service.
Definition: service.c:251
Handle to a service.
Definition: service.c:117
Element stored in a set.
const void * data
Actual data of the element.
uint16_t element_type
Application-specific element type.
uint16_t size
Number of bytes in the buffer pointed to by data.
Opaque handle to a set.
Definition: seti_api.c:40
Handle to an operation.
Definition: seti_api.c:106
Option for set operations.
An encrypted element key-value pair.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
int64_t value
a_i value, not disclosed to Bob.
Message type passed from requesting service Alice to responding service Bob to initiate a request and...