GNUnet  0.11.x
gnunet-service-scalarproduct-ecc_alice.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013-2017, 2021 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, ...) \
40  GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
41 
47 #define MAX_RESULT (1024 * 1024)
48 
55 #define MAX_RAM (1024)
56 
60 struct MpiElement
61 {
67  const struct GNUNET_HashCode *key;
68 
72  int64_t value;
73 };
74 
75 
81 {
86 
91 
96 
101 
106 
112 
118 
124 
129 
134 
139 
143  int product;
144 
149  uint32_t total;
150 
157 
163 
171 
177 };
178 
179 
183 static const struct GNUNET_CONFIGURATION_Handle *cfg;
184 
189 
193 static struct GNUNET_CRYPTO_EccScalar my_privkey;
194 
199 
204 
205 
214 static int
215 free_element_cb (void *cls,
216  const struct GNUNET_HashCode *key,
217  void *value)
218 {
220 
221  GNUNET_free (e);
222  return GNUNET_OK;
223 }
224 
225 
231 static void
233 {
234  if (GNUNET_YES == s->in_destroy)
235  return;
236  s->in_destroy = GNUNET_YES;
237  if (NULL != s->client)
238  {
239  struct GNUNET_SERVICE_Client *c = s->client;
240 
241  s->client = NULL;
243  }
244  if (NULL != s->channel)
245  {
247  s->channel = NULL;
248  }
249  if (NULL != s->intersected_elements)
250  {
253  s);
255  s->intersected_elements = NULL;
256  }
257  if (NULL != s->intersection_listen)
258  {
260  s->intersection_listen = NULL;
261  }
262  if (NULL != s->intersection_op)
263  {
265  "Set intersection, op still ongoing!\n");
267  s->intersection_op = NULL;
268  }
269  if (NULL != s->intersection_set)
270  {
272  s->intersection_set = NULL;
273  }
274  if (NULL != s->sorted_elements)
275  {
277  s->sorted_elements = NULL;
278  }
279  GNUNET_free (s);
280 }
281 
282 
289 static void
291 {
292  struct ClientResponseMessage *msg;
293  struct GNUNET_MQ_Envelope *e;
294 
295  if (NULL == session->client_mq)
296  return; /* no client left to be notified */
297  GNUNET_log (
299  "Sending session-end notification with status %d to client for session %s\n",
300  session->status,
301  GNUNET_h2s (&session->session_id));
302  e = GNUNET_MQ_msg (msg,
304  msg->product_length = htonl (0);
305  msg->status = htonl (session->status);
306  GNUNET_MQ_send (session->client_mq,
307  e);
308 }
309 
310 
317 static void
319 {
320  struct ClientResponseMessage *msg;
321  struct GNUNET_MQ_Envelope *e;
322  unsigned char *product_exported = NULL;
323  size_t product_length = 0;
324  int32_t range;
325  gcry_error_t rc;
326  gcry_mpi_t value;
327 
328  if (INT_MAX == s->product)
329  {
330  GNUNET_break (0);
332  return;
333  }
334  value = gcry_mpi_new (32);
335  if (0 > s->product)
336  {
337  range = -1;
338  gcry_mpi_set_ui (value,
339  -s->product);
340  }
341  else if (0 < s->product)
342  {
343  range = 1;
344  gcry_mpi_set_ui (value,
345  s->product);
346  }
347  else
348  {
349  /* result is exactly zero */
350  range = 0;
351  }
352  if ( (0 != range) &&
353  (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
354  &product_exported,
355  &product_length,
356  value))))
357  {
359  "gcry_mpi_scan",
360  rc);
362  return;
363  }
364  gcry_mpi_release (value);
366  product_length,
368  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
369  msg->range = htonl (range);
370  msg->product_length = htonl (product_length);
371  if (NULL != product_exported)
372  {
373  GNUNET_memcpy (&msg[1],
374  product_exported,
375  product_length);
376  GNUNET_free (product_exported);
377  }
379  e);
381  "Sent result to client, session %s has ended!\n",
382  GNUNET_h2s (&s->session_id));
383 }
384 
385 
395 static void
397  const struct GNUNET_CADET_Channel *channel)
398 {
399  struct AliceServiceSession *s = cls;
400 
402  "Peer disconnected, terminating session %s with peer %s\n",
403  GNUNET_h2s (&s->session_id),
404  GNUNET_i2s (&s->peer));
405  s->channel = NULL;
406  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
407  {
408  /* We didn't get an answer yet, fail with error */
411  }
412 }
413 
414 
422 static void
424  const struct EccBobCryptodataMessage *msg)
425 {
426  struct AliceServiceSession *s = cls;
427  uint32_t contained;
428 
429  contained = ntohl (msg->contained_element_count);
430  if (2 != contained)
431  {
432  GNUNET_break_op (0);
434  return;
435  }
436  if (NULL == s->sorted_elements)
437  {
438  /* we're not ready yet, how can Bob be? */
439  GNUNET_break_op (0);
441  return;
442  }
443  if (s->total != s->client_received_element_count)
444  {
445  /* we're not ready yet, how can Bob be? */
446  GNUNET_break_op (0);
448  return;
449  }
451  "Received %u crypto values from Bob\n",
452  (unsigned int) contained);
453  GNUNET_CADET_receive_done (s->channel);
454  {
455  struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
456  struct GNUNET_CRYPTO_EccPoint g_ai_bi;
457 
458  GNUNET_assert (
459  GNUNET_OK ==
460  GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
462  &g_i_b_i_a_inv));
463  GNUNET_assert (
464  GNUNET_OK ==
465  GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
466  &msg->prod_h_i_b_i,
467  &g_ai_bi));
469  &g_ai_bi);
470  if (INT_MAX == s->product)
471  {
472  /* result too big */
474  "Scalar product result out of range\n");
475  }
476  }
478 }
479 
480 
489 static int
490 copy_element_cb (void *cls,
491  const struct GNUNET_HashCode *key,
492  void *value)
493 {
494  struct AliceServiceSession *s = cls;
496 
498  e->value);
499  s->sorted_elements[s->used_element_count].key = &e->key;
500  s->used_element_count++;
501  return GNUNET_OK;
502 }
503 
504 
512 static int
513 element_cmp (const void *a,
514  const void *b)
515 {
516  const struct MpiElement *ma = a;
517  const struct MpiElement *mb = b;
518 
519  return GNUNET_CRYPTO_hash_cmp (ma->key,
520  mb->key);
521 }
522 
523 
528 #define ELEMENT_CAPACITY \
529  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
530  - sizeof(struct EccAliceCryptodataMessage)) \
531  / sizeof(struct GNUNET_CRYPTO_EccPoint))
532 
533 
540 static void
542 {
544  struct GNUNET_MQ_Envelope *e;
546  struct GNUNET_CRYPTO_EccScalar r_ia;
547  struct GNUNET_CRYPTO_EccScalar r_ia_ai;
548  unsigned int off;
549  unsigned int todo_count;
550 
553  struct MpiElement);
554  s->used_element_count = 0;
557  s);
559  "Finished intersection, %d items remain\n",
560  s->used_element_count);
561  qsort (s->sorted_elements,
563  sizeof(struct MpiElement),
564  &element_cmp);
565  off = 0;
566  while (off < s->used_element_count)
567  {
568  todo_count = s->used_element_count - off;
569  if (todo_count > ELEMENT_CAPACITY)
570  todo_count = ELEMENT_CAPACITY;
572  "Sending %u/%u crypto values to Bob\n",
573  (unsigned int) todo_count,
574  (unsigned int) s->used_element_count);
575 
576  e =
578  todo_count * 2
579  * sizeof(struct GNUNET_CRYPTO_EccPoint),
581  msg->contained_element_count = htonl (todo_count);
582  payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
583  for (unsigned int i = off; i < off + todo_count; i++)
584  {
585  struct GNUNET_CRYPTO_EccScalar r_i;
586  struct GNUNET_CRYPTO_EccPoint g_i;
587  struct GNUNET_CRYPTO_EccPoint h_i;
588 
589  /* r_i = random() mod n */
591  /* g_i = g^{r_i} */
594  &g_i));
595  /* r_ia = r_i * a */
596  crypto_core_ed25519_scalar_mul (r_ia.v,
597  r_i.v,
598  my_privkey.v);
599  /* r_ia_ai = r_ia + a_i */
600  {
601  int64_t val = s->sorted_elements[i].value;
602  struct GNUNET_CRYPTO_EccScalar vali;
603 
604  GNUNET_assert (INT64_MIN != val);
605  GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
606  &vali);
607  if (val > 0)
608  crypto_core_ed25519_scalar_add (r_ia_ai.v,
609  r_ia.v,
610  vali.v);
611  else
612  crypto_core_ed25519_scalar_sub (r_ia_ai.v,
613  r_ia.v,
614  vali.v);
615  }
616  /* h_i = g^{r_ia_ai} */
618  GNUNET_CRYPTO_ecc_dexp_mpi (&r_ia_ai,
619  &h_i));
620  memcpy (&payload[(i - off) * 2],
621  &g_i,
622  sizeof (g_i));
623  memcpy (&payload[(i - off) * 2 + 1],
624  &h_i,
625  sizeof (h_i));
626  }
627  off += todo_count;
629  e);
630  }
631 }
632 
633 
644 static void
646  const struct GNUNET_SETI_Element *element,
647  uint64_t current_size,
649 {
650  struct AliceServiceSession *s = cls;
651  struct GNUNET_SCALARPRODUCT_Element *se;
652 
653  switch (status)
654  {
656  /* this element has been removed from the set */
658  element->data);
659  GNUNET_assert (NULL != se);
661  "Intersection removed element with key %s and value %lld\n",
662  GNUNET_h2s (&se->key),
663  (long long) GNUNET_ntohll (se->value));
664  GNUNET_assert (
665  GNUNET_YES ==
667  element->data,
668  se));
669  GNUNET_free (se);
670  return;
672  s->intersection_op = NULL;
673  if (NULL != s->intersection_set)
674  {
676  s->intersection_set = NULL;
677  }
679  return;
681  /* unhandled status code */
682  LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
683  if (NULL != s->intersection_listen)
684  {
686  s->intersection_listen = NULL;
687  }
688  s->intersection_op = NULL;
689  if (NULL != s->intersection_set)
690  {
692  s->intersection_set = NULL;
693  }
696  return;
697 
698  default:
699  GNUNET_break (0);
700  return;
701  }
702 }
703 
704 
720 static void
722  const struct GNUNET_PeerIdentity *other_peer,
723  const struct GNUNET_MessageHeader *context_msg,
725 {
726  struct AliceServiceSession *s = cls;
727 
729  "Received intersection request from %s!\n",
730  GNUNET_i2s (other_peer));
731  if (0 != GNUNET_memcmp (other_peer,
732  &s->peer))
733  {
734  GNUNET_break_op (0);
735  return;
736  }
737  s->intersection_op
739  (struct GNUNET_SETI_Option[]){ { 0 } },
741  s);
742  if (NULL == s->intersection_op)
743  {
744  GNUNET_break (0);
747  return;
748  }
749  if (GNUNET_OK !=
750  GNUNET_SETI_commit (s->intersection_op,
751  s->intersection_set))
752  {
753  GNUNET_break (0);
756  return;
757  }
758 }
759 
760 
766 static void
768 {
769  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
770  GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
773  s),
775  };
777  struct GNUNET_MQ_Envelope *e;
778  struct GNUNET_HashCode set_sid;
779 
781  sizeof(struct GNUNET_HashCode),
782  &set_sid);
784  "Creating new channel for session with key %s.\n",
785  GNUNET_h2s (&s->session_id));
787  s,
788  &s->peer,
789  &s->session_id,
790  NULL,
792  cadet_handlers);
793  if (NULL == s->channel)
794  {
797  return;
798  }
801  &set_sid,
803  s);
804  if (NULL == s->intersection_listen)
805  {
808  s->channel = NULL;
810  return;
811  }
812 
813  e =
817  msg->session_id = s->session_id;
818  GNUNET_MQ_send (s->cadet_mq, e);
819 }
820 
821 
830 static int
832  void *cls,
834 {
835  struct AliceServiceSession *s = cls;
836  uint32_t contained_count;
837  uint16_t msize;
838 
839  msize = ntohs (msg->header.size);
840  contained_count = ntohl (msg->element_count_contained);
841  if ((msize !=
843  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
844  (0 == contained_count) ||
845  (s->total == s->client_received_element_count) ||
846  (s->total < s->client_received_element_count + contained_count))
847  {
848  GNUNET_break_op (0);
849  return GNUNET_SYSERR;
850  }
851  return GNUNET_OK;
852 }
853 
854 
862 static void
864  void *cls,
866 {
867  struct AliceServiceSession *s = cls;
868  uint32_t contained_count;
869  const struct GNUNET_SCALARPRODUCT_Element *elements;
870  struct GNUNET_SETI_Element set_elem;
871  struct GNUNET_SCALARPRODUCT_Element *elem;
872 
873  contained_count = ntohl (msg->element_count_contained);
874  s->client_received_element_count += contained_count;
875  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
876  for (uint32_t i = 0; i < contained_count; i++)
877  {
879  GNUNET_memcpy (elem,
880  &elements[i],
881  sizeof(struct GNUNET_SCALARPRODUCT_Element));
884  &elem->key,
885  elem,
887  {
888  GNUNET_break (0);
889  GNUNET_free (elem);
890  continue;
891  }
892  set_elem.data = &elem->key;
893  set_elem.size = sizeof(elem->key);
894  set_elem.element_type = 0;
895  GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
896  s->used_element_count++;
897  }
900  {
901  /* more to come */
903  "Received client multipart data, waiting for more!\n");
904  return;
905  }
906  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
908 }
909 
910 
919 static int
921  const struct AliceComputationMessage *msg)
922 {
923  struct AliceServiceSession *s = cls;
924  uint16_t msize;
925  uint32_t total_count;
926  uint32_t contained_count;
927 
928  if (NULL != s->intersected_elements)
929  {
930  /* only one concurrent session per client connection allowed,
931  simplifies logic a lot... */
932  GNUNET_break (0);
933  return GNUNET_SYSERR;
934  }
935  msize = ntohs (msg->header.size);
936  total_count = ntohl (msg->element_count_total);
937  contained_count = ntohl (msg->element_count_contained);
938  if ((0 == total_count) || (0 == contained_count) ||
939  (msize !=
940  (sizeof(struct AliceComputationMessage)
941  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
942  {
943  GNUNET_break_op (0);
944  return GNUNET_SYSERR;
945  }
946  return GNUNET_OK;
947 }
948 
949 
957 static void
959  const struct AliceComputationMessage *msg)
960 {
961  struct AliceServiceSession *s = cls;
962  uint32_t contained_count;
963  uint32_t total_count;
964  const struct GNUNET_SCALARPRODUCT_Element *elements;
965  struct GNUNET_SETI_Element set_elem;
966  struct GNUNET_SCALARPRODUCT_Element *elem;
967 
968  total_count = ntohl (msg->element_count_total);
969  contained_count = ntohl (msg->element_count_contained);
970  s->peer = msg->peer;
972  s->total = total_count;
973  s->client_received_element_count = contained_count;
974  s->session_id = msg->session_key;
975  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
978  GNUNET_YES);
980  for (uint32_t i = 0; i < contained_count; i++)
981  {
982  if (0 == GNUNET_ntohll (elements[i].value))
983  continue;
985  *elem = elements[i];
986  if (GNUNET_SYSERR ==
989  &elem->key,
990  elem,
992  {
993  /* element with same key encountered twice! */
994  GNUNET_break (0);
995  GNUNET_free (elem);
996  continue;
997  }
998  set_elem.data = &elem->key;
999  set_elem.size = sizeof(elem->key);
1000  set_elem.element_type = 0;
1002  &set_elem,
1003  NULL,
1004  NULL);
1005  s->used_element_count++;
1006  }
1008  if (s->total != s->client_received_element_count)
1009  {
1010  /* wait for multipart msg */
1012  "Received partial client request, waiting for more!\n");
1013  return;
1014  }
1016  "Launching computation\n");
1018 }
1019 
1020 
1027 static void
1028 shutdown_task (void *cls)
1029 {
1031  "Shutting down, initiating cleanup.\n");
1032  // FIXME: we have to cut our connections to CADET first!
1033  if (NULL != my_cadet)
1034  {
1036  my_cadet = NULL;
1037  }
1038  if (NULL != edc)
1039  {
1041  edc = NULL;
1042  }
1043 }
1044 
1045 
1056 static void *
1058  struct GNUNET_SERVICE_Client *client,
1059  struct GNUNET_MQ_Handle *mq)
1060 {
1061  struct AliceServiceSession *s;
1062 
1063  s = GNUNET_new (struct AliceServiceSession);
1064  s->client = client;
1065  s->client_mq = mq;
1066  return s;
1067 }
1068 
1069 
1080 static void
1082  struct GNUNET_SERVICE_Client *client,
1083  void *app_cls)
1084 {
1085  struct AliceServiceSession *s = app_cls;
1086 
1088  "Client %p disconnected from us.\n",
1089  client);
1090  s->client = NULL;
1091  s->client_mq = NULL;
1093 }
1094 
1095 
1103 static void
1104 run (void *cls,
1105  const struct GNUNET_CONFIGURATION_Handle *c,
1107 {
1108  cfg = c;
1110  MAX_RAM);
1111  /* Select a random 'a' value for Alice */
1113  &my_privkey_inv);
1115  if (NULL == my_cadet)
1116  {
1118  _ ("Connect to CADET failed\n"));
1120  return;
1121  }
1123  NULL);
1124 }
1125 
1126 
1131  "scalarproduct-alice",
1133  &run,
1136  NULL,
1137  GNUNET_MQ_hd_var_size (alice_client_message,
1139  struct AliceComputationMessage,
1140  NULL),
1142  alice_client_message_multipart,
1145  NULL),
1147 
1148 
1149 /* end of gnunet-service-scalarproduct-ecc_alice.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define INT_MAX
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_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 cb_intersection_request_alice(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
Called when another peer wants to do a set operation with the local peer.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static struct GNUNET_CRYPTO_EccScalar my_privkey
Alice's private key ('a').
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
static int check_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice's client request message.
#define MAX_RAM
How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes t...
static void handle_bobs_cryptodata_message(void *cls, const struct EccBobCryptodataMessage *msg)
Handle a response we got from another service we wanted to calculate a scalarproduct with.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static void handle_alice_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
#define ELEMENT_CAPACITY
Maximum number of elements we can put into a single cryptodata message.
static void shutdown_task(void *cls)
Task run during shutdown.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
#define MAX_RESULT
Maximum allowed result value for the scalarproduct computation.
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv
Inverse of Alice's private key ('a_inv').
static void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static void handle_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice's client request message.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
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_client_response(struct AliceServiceSession *s)
Prepare the final (positive) response we will send to Alice's client.
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 check_alice_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called to free elements.
GNUNET_SERVICE_MAIN("scalarproduct-alice", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL), GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
#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_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#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
void GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccScalar *r, struct GNUNET_CRYPTO_EccScalar *r_neg)
Obtain a random scalar for point multiplication on the curve and its additive inverse.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_dexp_mpi(const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi(const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the point p on the elliptic curve by val.
int GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *input)
Calculate ECC discrete logarithm for small factors.
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
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.
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
void GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccScalar *r)
Generate a random value mod n.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add(const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
Add two points on the elliptic curve.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1031
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
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
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
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_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_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1022
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)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
@ GNUNET_MQ_PRIO_CRITICAL_CONTROL
Highest priority, control traffic (e.g.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE
Client -> Alice multipart.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE
Client -> Alice.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
@ 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.
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_accept(struct GNUNET_SETI_Request *request, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SETI_listen().
Definition: seti_api.c:780
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_ListenHandle * GNUNET_SETI_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETI_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: seti_api.c:715
void GNUNET_SETI_listen_cancel(struct GNUNET_SETI_ListenHandle *lh)
Cancel the given listen operation.
Definition: seti_api.c:747
@ 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 _(String)
GNU gettext support macro.
Definition: platform.h:177
Scalar Product API Message Types.
#define LOG_GCRY(level, cmd, rc)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition: scalarproduct.h:35
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:46
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value'd elements transmitted to us.
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
int product
The computed scalar product.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which will conduction an intersection.
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
uint32_t client_received_element_count
Already transferred elements from client to us.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
struct GNUNET_PeerIdentity peer
Alice or Bob's peerID.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
struct GNUNET_SETI_ListenHandle * intersection_listen
Handle to Alice's Intersection operation listening for Bob.
uint32_t used_element_count
How many elements actually are used for the scalar product.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Message type passed from service client to finalize a session as requester or responder.
multipart messages following struct ComputationMessage
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
Message type passed from responding service Bob to responding service Alice to complete a request and...
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
Opaque handle to a channel.
Definition: cadet.h:117
Opaque handle to the service.
Definition: cadet_api.c:39
Internal representation of the hash map.
Internal structure used to cache pre-calculated values for DLOG calculation.
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
A ECC scalar for use in point multiplications.
unsigned char v[256/8]
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
Header for all communications.
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
Opaque handle to a listen operation.
Definition: seti_api.c:163
Handle to an operation.
Definition: seti_api.c:106
Option for set operations.
Handle for a set operation request from another peer.
Definition: seti_api.c:86
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.