GNUnet  0.19.2
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, 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, ...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
40 
41 
45 struct MpiElement
46 {
52  const struct GNUNET_HashCode *key;
53 
57  int64_t value;
58 };
59 
60 
66 {
71 
76 
81 
87 
93 
98 
103 
108 
113 
117  uint32_t total;
118 
124 
131 
137 
145 
150 
155 
159  struct GNUNET_PeerIdentity peer;
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  if (GNUNET_YES == s->in_destroy)
217  return;
218  s->in_destroy = GNUNET_YES;
219  if (NULL != s->client)
220  {
221  struct GNUNET_SERVICE_Client *c = s->client;
222 
223  s->client = NULL;
225  }
226  if (NULL != s->intersected_elements)
227  {
230  NULL);
232  s->intersected_elements = NULL;
233  }
234  if (NULL != s->intersection_op)
235  {
237  s->intersection_op = NULL;
238  }
239  if (NULL != s->intersection_set)
240  {
242  s->intersection_set = NULL;
243  }
244  if (NULL != s->sorted_elements)
245  {
247  s->sorted_elements = NULL;
248  }
249  if (NULL != s->port)
250  {
252  s->port = NULL;
253  }
254  if (NULL != s->channel)
255  {
257  s->channel = NULL;
258  }
259  GNUNET_free (s);
260 }
261 
262 
270 static void
272 {
273  struct ClientResponseMessage *msg;
274  struct GNUNET_MQ_Envelope *e;
275 
276  if (NULL == session->client_mq)
277  return; /* no client left to be notified */
279  "Sending session-end notification with status %d to client for session %s\n",
280  session->status,
281  GNUNET_h2s (&session->session_id));
282  e = GNUNET_MQ_msg (msg,
284  msg->range = 0;
285  msg->product_length = htonl (0);
286  msg->status = htonl (session->status);
287  GNUNET_MQ_send (session->client_mq,
288  e);
289 }
290 
291 
301 static void
303  const struct GNUNET_CADET_Channel *channel)
304 {
305  struct BobServiceSession *s = cls;
306 
308  "Peer disconnected, terminating session %s with peer %s\n",
309  GNUNET_h2s (&s->session_id),
310  GNUNET_i2s (&s->peer));
311  s->channel = NULL;
312  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
313  {
316  }
318 }
319 
320 
325 static void
326 bob_cadet_done_cb (void *cls)
327 {
328  struct BobServiceSession *session = cls;
329 
332 }
333 
334 
340 static void
342 {
344  struct GNUNET_MQ_Envelope *e;
345 
347  "Sending response to Alice\n");
348  e = GNUNET_MQ_msg (msg,
350  msg->contained_element_count = htonl (2);
351  msg->prod_g_i_b_i = s->prod_g_i_b_i;
352  msg->prod_h_i_b_i = s->prod_h_i_b_i;
355  s);
357  e);
358 }
359 
360 
369 static int
370 copy_element_cb (void *cls,
371  const struct GNUNET_HashCode *key,
372  void *value)
373 {
374  struct BobServiceSession *s = cls;
376 
378  e->value);
379  s->sorted_elements[s->used_element_count].key = &e->key;
380  s->used_element_count++;
381  return GNUNET_OK;
382 }
383 
384 
393 static int
394 element_cmp (const void *a,
395  const void *b)
396 {
397  const struct MpiElement *ma = a;
398  const struct MpiElement *mb = b;
399 
400  return GNUNET_CRYPTO_hash_cmp (ma->key,
401  mb->key);
402 }
403 
404 
414 static int
416  const struct EccAliceCryptodataMessage *msg)
417 {
418  struct BobServiceSession *s = cls;
419  uint32_t contained_elements;
420  size_t msg_length;
421  uint16_t msize;
422  unsigned int max;
423 
424  msize = ntohs (msg->header.size);
425  if (msize <= sizeof(struct EccAliceCryptodataMessage))
426  {
427  GNUNET_break_op (0);
428  return GNUNET_SYSERR;
429  }
430  contained_elements = ntohl (msg->contained_element_count);
431  /* Our intersection may still be ongoing, but this is nevertheless
432  an upper bound on the required array size */
433  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
434  msg_length = sizeof(struct EccAliceCryptodataMessage)
435  + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
436  if ((msize != msg_length) ||
437  (0 == contained_elements) ||
438  (contained_elements > UINT16_MAX) ||
439  (max < contained_elements + s->cadet_received_element_count))
440  {
441  GNUNET_break_op (0);
442  return GNUNET_SYSERR;
443  }
444  return GNUNET_OK;
445 }
446 
447 
455 static void
457  const struct EccAliceCryptodataMessage *msg)
458 {
459  struct BobServiceSession *s = cls;
460  const struct GNUNET_CRYPTO_EccPoint *payload;
461  uint32_t contained_elements;
462  unsigned int max;
463  const struct GNUNET_CRYPTO_EccPoint *g_i;
464  const struct GNUNET_CRYPTO_EccPoint *h_i;
465  struct GNUNET_CRYPTO_EccPoint g_i_b_i;
466  struct GNUNET_CRYPTO_EccPoint h_i_b_i;
467 
468  contained_elements = ntohl (msg->contained_element_count);
470  /* sort our vector for the computation */
471  if (NULL == s->sorted_elements)
472  {
473  s->sorted_elements
476  struct MpiElement);
477  s->used_element_count = 0;
480  s);
481  qsort (s->sorted_elements,
483  sizeof(struct MpiElement),
484  &element_cmp);
485  }
486 
488  "Received %u crypto values from Alice\n",
489  (unsigned int) contained_elements);
490  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
491 
492  for (unsigned int i = 0; i < contained_elements; i++)
493  {
494  int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
495  struct GNUNET_CRYPTO_EccScalar vali;
496 
497  GNUNET_assert (INT64_MIN != val);
498  GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
499  &vali);
500  if (val < 0)
501  crypto_core_ed25519_scalar_negate (vali.v,
502  vali.v);
503  g_i = &payload[i * 2];
504  /* g_i_b_i = g_i^vali */
507  &vali,
508  &g_i_b_i));
509  h_i = &payload[i * 2 + 1];
510  /* h_i_b_i = h_i^vali */
513  &vali,
514  &h_i_b_i));
515  if (0 == i + s->cadet_received_element_count)
516  {
517  /* first iteration, nothing to add */
518  s->prod_g_i_b_i = g_i_b_i;
519  s->prod_h_i_b_i = h_i_b_i;
520  }
521  else
522  {
523  /* further iterations, cummulate resulting value */
526  &g_i_b_i,
527  &s->prod_g_i_b_i));
530  &h_i_b_i,
531  &s->prod_h_i_b_i));
532  }
533  }
534  s->cadet_received_element_count += contained_elements;
535  if ((s->cadet_received_element_count == max) &&
536  (NULL == s->intersection_op))
537  {
538  /* intersection has finished also on our side, and
539  we got the full set, so we can proceed with the
540  CADET response(s) */
542  }
544 }
545 
546 
556 static void
558  const struct GNUNET_SETI_Element *element,
559  uint64_t current_size,
561 {
562  struct BobServiceSession *s = cls;
563  struct GNUNET_SCALARPRODUCT_Element *se;
564 
565  switch (status)
566  {
568  /* this element has been removed from the set */
570  element->data);
571  GNUNET_assert (NULL != se);
573  "Removed element with key %s and value %lld\n",
574  GNUNET_h2s (&se->key),
575  (long long) GNUNET_ntohll (se->value));
579  element->data,
580  se));
581  GNUNET_free (se);
582  return;
584  s->intersection_op = NULL;
585  GNUNET_break (NULL == s->intersection_set);
588  "Finished intersection, %d items remain\n",
592  {
593  /* CADET transmission from Alice is also already done,
594  start with our own reply */
596  }
597  return;
599  /* unhandled status code */
601  "Set intersection failed!\n");
602  s->intersection_op = NULL;
603  if (NULL != s->intersection_set)
604  {
606  s->intersection_set = NULL;
607  }
610  return;
611 
612  default:
613  GNUNET_break (0);
614  return;
615  }
616 }
617 
618 
625 static void
627 {
628  struct GNUNET_HashCode set_sid;
629 
631  sizeof(struct GNUNET_HashCode),
632  &set_sid);
634  "Got session with key %s and %u elements, starting intersection.\n",
635  GNUNET_h2s (&s->session_id),
636  (unsigned int) s->total);
637 
638  s->intersection_op
639  = GNUNET_SETI_prepare (&s->peer,
640  &set_sid,
641  NULL,
642  (struct GNUNET_SETI_Option[]) { { 0 } },
644  s);
645  if (GNUNET_OK !=
646  GNUNET_SETI_commit (s->intersection_op,
647  s->intersection_set))
648  {
649  GNUNET_break (0);
652  return;
653  }
654  GNUNET_SETI_destroy (s->intersection_set);
655  s->intersection_set = NULL;
656 }
657 
658 
665 static void
667  const struct EccServiceRequestMessage *msg)
668 {
669  struct BobServiceSession *s = cls;
670 
671  s->session_id = msg->session_id; // ??
672  if (s->client_received_element_count < s->total)
673  {
675  "Alice ready, still waiting for Bob client data!\n");
676  return;
677  }
679  "Both ready, launching intersection!\n");
681 }
682 
683 
694 static void *
697  const struct GNUNET_PeerIdentity *initiator)
698 {
699  struct BobServiceSession *s = cls;
700 
702  "New incoming channel from peer %s.\n",
703  GNUNET_i2s (initiator));
704  GNUNET_CADET_close_port (s->port);
705  s->port = NULL;
706  s->peer = *initiator;
707  s->channel = channel;
708  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
709  return s;
710 }
711 
712 
720 static int
722  void *cls,
724 {
725  struct BobServiceSession *s = cls;
726  uint32_t contained_count;
727  uint16_t msize;
728 
729  msize = ntohs (msg->header.size);
730  contained_count = ntohl (msg->element_count_contained);
731  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
732  + contained_count * sizeof(struct
734  (0 == contained_count) ||
735  (UINT16_MAX < contained_count) ||
736  (s->total == s->client_received_element_count) ||
737  (s->total < s->client_received_element_count + contained_count))
738  {
739  GNUNET_break (0);
740  return GNUNET_SYSERR;
741  }
742  return GNUNET_OK;
743 }
744 
745 
753 static void
755  void *cls,
757 {
758  struct BobServiceSession *s = cls;
759  uint32_t contained_count;
760  const struct GNUNET_SCALARPRODUCT_Element *elements;
761  struct GNUNET_SETI_Element set_elem;
762  struct GNUNET_SCALARPRODUCT_Element *elem;
763 
764  contained_count = ntohl (msg->element_count_contained);
765  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
766  for (uint32_t i = 0; i < contained_count; i++)
767  {
769  GNUNET_memcpy (elem,
770  &elements[i],
771  sizeof(struct GNUNET_SCALARPRODUCT_Element));
772  if (GNUNET_SYSERR ==
774  &elem->key,
775  elem,
777  {
778  GNUNET_break (0);
779  GNUNET_free (elem);
780  continue;
781  }
782  set_elem.data = &elem->key;
783  set_elem.size = sizeof(elem->key);
784  set_elem.element_type = 0;
786  &set_elem,
787  NULL, NULL);
788  }
789  s->client_received_element_count += contained_count;
792  {
793  /* more to come */
795  "Request still partial, waiting for more client data!\n");
796  return;
797  }
798  if (NULL == s->channel)
799  {
800  /* no Alice waiting for this request, wait for Alice */
802  "Client ready, still waiting for Alice!\n");
803  return;
804  }
806  "Both ready, launching intersection!\n");
807  start_intersection (s);
808 }
809 
810 
819 static int
821  const struct BobComputationMessage *msg)
822 {
823  struct BobServiceSession *s = cls;
824  uint32_t contained_count;
825  uint32_t total_count;
826  uint16_t msize;
827 
828  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
829  {
830  GNUNET_break (0);
831  return GNUNET_SYSERR;
832  }
833  msize = ntohs (msg->header.size);
834  total_count = ntohl (msg->element_count_total);
835  contained_count = ntohl (msg->element_count_contained);
836  if ((0 == total_count) ||
837  (0 == contained_count) ||
838  (UINT16_MAX < contained_count) ||
839  (msize != (sizeof(struct BobComputationMessage)
840  + contained_count * sizeof(struct
842  {
843  GNUNET_break_op (0);
844  return GNUNET_SYSERR;
845  }
846  return GNUNET_OK;
847 }
848 
849 
858 static void
860  const struct BobComputationMessage *msg)
861 {
862  struct BobServiceSession *s = cls;
863  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
864  GNUNET_MQ_hd_fixed_size (alices_computation_request,
867  s),
868  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
871  s),
873  };
874  uint32_t contained_count;
875  uint32_t total_count;
876  const struct GNUNET_SCALARPRODUCT_Element *elements;
877  struct GNUNET_SETI_Element set_elem;
878  struct GNUNET_SCALARPRODUCT_Element *elem;
879 
880  total_count = ntohl (msg->element_count_total);
881  contained_count = ntohl (msg->element_count_contained);
882 
884  s->total = total_count;
885  s->client_received_element_count = contained_count;
886  s->session_id = msg->session_key;
887  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
890  GNUNET_YES);
892  for (uint32_t i = 0; i < contained_count; i++)
893  {
894  if (0 == GNUNET_ntohll (elements[i].value))
895  continue;
897  GNUNET_memcpy (elem,
898  &elements[i],
899  sizeof(struct GNUNET_SCALARPRODUCT_Element));
900  if (GNUNET_SYSERR ==
902  &elem->key,
903  elem,
905  {
906  GNUNET_break (0);
907  GNUNET_free (elem);
908  continue;
909  }
910  set_elem.data = &elem->key;
911  set_elem.size = sizeof(elem->key);
912  set_elem.element_type = 0;
914  &set_elem,
915  NULL, NULL);
916  s->used_element_count++;
917  }
920  "Received client request, opening port %s!\n",
921  GNUNET_h2s (&msg->session_key));
923  &msg->session_key,
925  s,
926  NULL,
928  cadet_handlers);
929  if (NULL == s->port)
930  {
931  GNUNET_break (0);
933  return;
934  }
935 }
936 
937 
943 static void
944 shutdown_task (void *cls)
945 {
947  "Shutting down, initiating cleanup.\n");
948  // FIXME: we have to cut our connections to CADET first!
949  if (NULL != my_cadet)
950  {
952  my_cadet = NULL;
953  }
954  if (NULL != edc)
955  {
957  edc = NULL;
958  }
959 }
960 
961 
972 static void *
973 client_connect_cb (void *cls,
974  struct GNUNET_SERVICE_Client *client,
975  struct GNUNET_MQ_Handle *mq)
976 {
977  struct BobServiceSession *s;
978 
979  s = GNUNET_new (struct BobServiceSession);
980  s->client = client;
981  s->client_mq = mq;
982  return s;
983 }
984 
985 
996 static void
999  void *app_cls)
1000 {
1001  struct BobServiceSession *s = app_cls;
1002 
1004  "Client disconnected from us.\n");
1005  s->client = NULL;
1007 }
1008 
1009 
1017 static void
1018 run (void *cls,
1019  const struct GNUNET_CONFIGURATION_Handle *c,
1021 {
1022  cfg = c;
1023  /* We don't really do DLOG, so we can setup with very minimal resources */
1024  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1025  2 /* RAM */);
1028  NULL);
1029  if (NULL == my_cadet)
1030  {
1032  _ ("Connect to CADET failed\n"));
1034  return;
1035  }
1036 }
1037 
1038 
1043  ("scalarproduct-bob",
1045  &run,
1048  NULL,
1049  GNUNET_MQ_hd_var_size (bob_client_message,
1051  struct BobComputationMessage,
1052  NULL),
1053  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
1056  NULL),
1058 
1059 
1060 /* end of gnunet-service-scalarproduct-ecc_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_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 struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
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.
static void start_intersection(struct BobServiceSession *s)
We've paired up a client session with an incoming CADET request.
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.
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.
static void shutdown_task(void *cls)
Task run during shutdown.
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 EccServiceRequestMessage *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 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.
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 void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
#define LOG(kind,...)
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.
Constants for network applications operating on top of the CADET service.
CADET service; establish channels to distant peers.
Core service; the main API for encrypted P2P communications.
Constants for network protocols.
Two-peer set intersection operations.
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:872
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
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:1066
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:894
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:954
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:220
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash 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_log(kind,...)
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.
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
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.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_SYSERR
#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_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#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:638
#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_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
Client -> Bob.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB
Client -> Bob multipart.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
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:534
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:1303
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
@ 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:810
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:513
@ 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.
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:89
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.
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.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
Product of the h_i^{b_i}.
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 s
Bob's "s".
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
Product of the g_i^{b_i}.
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
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:116
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.
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:87
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:252
Handle to a service.
Definition: service.c:118
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.