GNUnet  0.11.x
gnunet-service-scalarproduct-ecc_bob.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013-2017, 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 
107  struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i;
108 
112  struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i;
113 
117  uint32_t total;
118 
124 
131 
137 
145 
150 
155 
160 
165 
170 };
171 
172 
176 static const struct GNUNET_CONFIGURATION_Handle *cfg;
177 
182 
187 
188 
196 static int
197 free_element_cb (void *cls,
198  const struct GNUNET_HashCode *key,
199  void *value)
200 {
201  struct GNUNET_SCALARPRODUCT_Element *element = value;
202 
203  GNUNET_free (element);
204  return GNUNET_OK;
205 }
206 
207 
213 static void
215 {
216  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 
303 static void
305  const struct GNUNET_CADET_Channel *channel)
306 {
307  struct BobServiceSession *s = cls;
308 
310  "Peer disconnected, terminating session %s with peer %s\n",
311  GNUNET_h2s (&s->session_id),
312  GNUNET_i2s (&s->peer));
313  s->channel = NULL;
315  {
318  }
320 }
321 
322 
327 static void
328 bob_cadet_done_cb (void *cls)
329 {
330  struct BobServiceSession *session = cls;
331 
334 }
335 
336 
342 static void
344 {
346  struct GNUNET_MQ_Envelope *e;
347 
349  "Sending response to Alice\n");
350  e = GNUNET_MQ_msg (msg,
352  msg->contained_element_count = htonl (2);
353  msg->prod_g_i_b_i = s->prod_g_i_b_i;
354  msg->prod_h_i_b_i = s->prod_h_i_b_i;
357  s);
359  e);
360 }
361 
362 
371 static int
372 copy_element_cb (void *cls,
373  const struct GNUNET_HashCode *key,
374  void *value)
375 {
376  struct BobServiceSession *s = cls;
378 
380  e->value);
382  s->used_element_count++;
383  return GNUNET_OK;
384 }
385 
386 
395 static int
396 element_cmp (const void *a,
397  const void *b)
398 {
399  const struct MpiElement *ma = a;
400  const struct MpiElement *mb = b;
401 
402  return GNUNET_CRYPTO_hash_cmp (ma->key,
403  mb->key);
404 }
405 
406 
416 static int
418  const struct EccAliceCryptodataMessage *msg)
419 {
420  struct BobServiceSession *s = cls;
421  uint32_t contained_elements;
422  size_t msg_length;
423  uint16_t msize;
424  unsigned int max;
425 
426  msize = ntohs (msg->header.size);
427  if (msize <= sizeof(struct EccAliceCryptodataMessage))
428  {
429  GNUNET_break_op (0);
430  return GNUNET_SYSERR;
431  }
432  contained_elements = ntohl (msg->contained_element_count);
433  /* Our intersection may still be ongoing, but this is nevertheless
434  an upper bound on the required array size */
436  msg_length = sizeof(struct EccAliceCryptodataMessage)
437  + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
438  if ((msize != msg_length) ||
439  (0 == contained_elements) ||
440  (contained_elements > UINT16_MAX) ||
441  (max < contained_elements + s->cadet_received_element_count))
442  {
443  GNUNET_break_op (0);
444  return GNUNET_SYSERR;
445  }
446  return GNUNET_OK;
447 }
448 
449 
457 static void
459  const struct EccAliceCryptodataMessage *msg)
460 {
461  struct BobServiceSession *s = cls;
462  const struct GNUNET_CRYPTO_EccPoint *payload;
463  uint32_t contained_elements;
464  unsigned int max;
465  const struct GNUNET_CRYPTO_EccPoint *g_i;
466  const struct GNUNET_CRYPTO_EccPoint *h_i;
467  struct GNUNET_CRYPTO_EccPoint g_i_b_i;
468  struct GNUNET_CRYPTO_EccPoint h_i_b_i;
469 
470  contained_elements = ntohl (msg->contained_element_count);
472  /* sort our vector for the computation */
473  if (NULL == s->sorted_elements)
474  {
475  s->sorted_elements
478  struct MpiElement);
479  s->used_element_count = 0;
482  s);
483  qsort (s->sorted_elements,
485  sizeof(struct MpiElement),
486  &element_cmp);
487  }
488 
490  "Received %u crypto values from Alice\n",
491  (unsigned int) contained_elements);
492  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
493 
494  for (unsigned int i = 0; i < contained_elements; i++)
495  {
496  int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
497  struct GNUNET_CRYPTO_EccScalar vali;
498 
499  GNUNET_assert (INT64_MIN != val);
500  GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
501  &vali);
502  if (val < 0)
503  crypto_core_ed25519_scalar_negate (vali.v,
504  vali.v);
505  g_i = &payload[i * 2];
506  /* g_i_b_i = g_i^vali */
509  &vali,
510  &g_i_b_i));
511  h_i = &payload[i * 2 + 1];
512  /* h_i_b_i = h_i^vali */
515  &vali,
516  &h_i_b_i));
517  if (0 == i + s->cadet_received_element_count)
518  {
519  /* first iteration, nothing to add */
520  s->prod_g_i_b_i = g_i_b_i;
521  s->prod_h_i_b_i = h_i_b_i;
522  }
523  else
524  {
525  /* further iterations, cummulate resulting value */
528  &g_i_b_i,
529  &s->prod_g_i_b_i));
532  &h_i_b_i,
533  &s->prod_h_i_b_i));
534  }
535  }
536  s->cadet_received_element_count += contained_elements;
537  if ((s->cadet_received_element_count == max) &&
538  (NULL == s->intersection_op))
539  {
540  /* intersection has finished also on our side, and
541  we got the full set, so we can proceed with the
542  CADET response(s) */
544  }
546 }
547 
548 
558 static void
560  const struct GNUNET_SETI_Element *element,
561  uint64_t current_size,
563 {
564  struct BobServiceSession *s = cls;
565  struct GNUNET_SCALARPRODUCT_Element *se;
566 
567  switch (status)
568  {
570  /* this element has been removed from the set */
572  element->data);
573  GNUNET_assert (NULL != se);
575  "Removed element with key %s and value %lld\n",
576  GNUNET_h2s (&se->key),
577  (long long) GNUNET_ntohll (se->value));
581  element->data,
582  se));
583  GNUNET_free (se);
584  return;
586  s->intersection_op = NULL;
587  GNUNET_break (NULL == s->intersection_set);
590  "Finished intersection, %d items remain\n",
594  {
595  /* CADET transmission from Alice is also already done,
596  start with our own reply */
598  }
599  return;
601  /* unhandled status code */
603  "Set intersection failed!\n");
604  s->intersection_op = NULL;
605  if (NULL != s->intersection_set)
606  {
608  s->intersection_set = NULL;
609  }
612  return;
613 
614  default:
615  GNUNET_break (0);
616  return;
617  }
618 }
619 
620 
627 static void
629 {
630  struct GNUNET_HashCode set_sid;
631 
633  sizeof(struct GNUNET_HashCode),
634  &set_sid);
636  "Got session with key %s and %u elements, starting intersection.\n",
637  GNUNET_h2s (&s->session_id),
638  (unsigned int) s->total);
639 
640  s->intersection_op
641  = GNUNET_SETI_prepare (&s->peer,
642  &set_sid,
643  NULL,
644  (struct GNUNET_SETI_Option[]) { { 0 } },
646  s);
647  if (GNUNET_OK !=
648  GNUNET_SETI_commit (s->intersection_op,
649  s->intersection_set))
650  {
651  GNUNET_break (0);
654  return;
655  }
656  GNUNET_SETI_destroy (s->intersection_set);
657  s->intersection_set = NULL;
658 }
659 
660 
667 static void
669  const struct EccServiceRequestMessage *msg)
670 {
671  struct BobServiceSession *s = cls;
672 
673  s->session_id = msg->session_id; // ??
675  {
677  "Alice ready, still waiting for Bob client data!\n");
678  return;
679  }
681  "Both ready, launching intersection!\n");
682  start_intersection (s);
683 }
684 
685 
696 static void *
699  const struct GNUNET_PeerIdentity *initiator)
700 {
701  struct BobServiceSession *s = cls;
702 
704  "New incoming channel from peer %s.\n",
705  GNUNET_i2s (initiator));
707  s->port = NULL;
708  s->peer = *initiator;
709  s->channel = channel;
711  return s;
712 }
713 
714 
722 static int
724  void *cls,
726 {
727  struct BobServiceSession *s = cls;
728  uint32_t contained_count;
729  uint16_t msize;
730 
731  msize = ntohs (msg->header.size);
732  contained_count = ntohl (msg->element_count_contained);
733  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
734  + contained_count * sizeof(struct
736  (0 == contained_count) ||
737  (UINT16_MAX < contained_count) ||
739  (s->total < s->client_received_element_count + contained_count))
740  {
741  GNUNET_break (0);
742  return GNUNET_SYSERR;
743  }
744  return GNUNET_OK;
745 }
746 
747 
755 static void
757  void *cls,
759 {
760  struct BobServiceSession *s = cls;
761  uint32_t contained_count;
762  const struct GNUNET_SCALARPRODUCT_Element *elements;
763  struct GNUNET_SETI_Element set_elem;
764  struct GNUNET_SCALARPRODUCT_Element *elem;
765 
766  contained_count = ntohl (msg->element_count_contained);
767  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
768  for (uint32_t i = 0; i < contained_count; i++)
769  {
771  GNUNET_memcpy (elem,
772  &elements[i],
773  sizeof(struct GNUNET_SCALARPRODUCT_Element));
774  if (GNUNET_SYSERR ==
776  &elem->key,
777  elem,
779  {
780  GNUNET_break (0);
781  GNUNET_free (elem);
782  continue;
783  }
784  set_elem.data = &elem->key;
785  set_elem.size = sizeof(elem->key);
786  set_elem.element_type = 0;
788  &set_elem,
789  NULL, NULL);
790  }
791  s->client_received_element_count += contained_count;
794  {
795  /* more to come */
797  "Request still partial, waiting for more client data!\n");
798  return;
799  }
800  if (NULL == s->channel)
801  {
802  /* no Alice waiting for this request, wait for Alice */
804  "Client ready, still waiting for Alice!\n");
805  return;
806  }
808  "Both ready, launching intersection!\n");
809  start_intersection (s);
810 }
811 
812 
821 static int
823  const struct BobComputationMessage *msg)
824 {
825  struct BobServiceSession *s = cls;
826  uint32_t contained_count;
827  uint32_t total_count;
828  uint16_t msize;
829 
831  {
832  GNUNET_break (0);
833  return GNUNET_SYSERR;
834  }
835  msize = ntohs (msg->header.size);
836  total_count = ntohl (msg->element_count_total);
837  contained_count = ntohl (msg->element_count_contained);
838  if ((0 == total_count) ||
839  (0 == contained_count) ||
840  (UINT16_MAX < contained_count) ||
841  (msize != (sizeof(struct BobComputationMessage)
842  + contained_count * sizeof(struct
844  {
845  GNUNET_break_op (0);
846  return GNUNET_SYSERR;
847  }
848  return GNUNET_OK;
849 }
850 
851 
860 static void
862  const struct BobComputationMessage *msg)
863 {
864  struct BobServiceSession *s = cls;
865  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
866  GNUNET_MQ_hd_fixed_size (alices_computation_request,
869  s),
870  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
873  s),
875  };
876  uint32_t contained_count;
877  uint32_t total_count;
878  const struct GNUNET_SCALARPRODUCT_Element *elements;
879  struct GNUNET_SETI_Element set_elem;
880  struct GNUNET_SCALARPRODUCT_Element *elem;
881 
882  total_count = ntohl (msg->element_count_total);
883  contained_count = ntohl (msg->element_count_contained);
884 
886  s->total = total_count;
887  s->client_received_element_count = contained_count;
888  s->session_id = msg->session_key;
889  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
892  GNUNET_YES);
894  for (uint32_t i = 0; i < contained_count; i++)
895  {
896  if (0 == GNUNET_ntohll (elements[i].value))
897  continue;
899  GNUNET_memcpy (elem,
900  &elements[i],
901  sizeof(struct GNUNET_SCALARPRODUCT_Element));
902  if (GNUNET_SYSERR ==
904  &elem->key,
905  elem,
907  {
908  GNUNET_break (0);
909  GNUNET_free (elem);
910  continue;
911  }
912  set_elem.data = &elem->key;
913  set_elem.size = sizeof(elem->key);
914  set_elem.element_type = 0;
916  &set_elem,
917  NULL, NULL);
918  s->used_element_count++;
919  }
922  "Received client request, opening port %s!\n",
923  GNUNET_h2s (&msg->session_key));
924  s->port = GNUNET_CADET_open_port (my_cadet,
925  &msg->session_key,
927  s,
928  NULL,
930  cadet_handlers);
931  if (NULL == s->port)
932  {
933  GNUNET_break (0);
935  return;
936  }
937 }
938 
939 
945 static void
946 shutdown_task (void *cls)
947 {
949  "Shutting down, initiating cleanup.\n");
950  // FIXME: we have to cut our connections to CADET first!
951  if (NULL != my_cadet)
952  {
953  GNUNET_CADET_disconnect (my_cadet);
954  my_cadet = NULL;
955  }
956  if (NULL != edc)
957  {
959  edc = NULL;
960  }
961 }
962 
963 
974 static void *
975 client_connect_cb (void *cls,
976  struct GNUNET_SERVICE_Client *client,
977  struct GNUNET_MQ_Handle *mq)
978 {
979  struct BobServiceSession *s;
980 
981  s = GNUNET_new (struct BobServiceSession);
982  s->client = client;
983  s->client_mq = mq;
984  return s;
985 }
986 
987 
998 static void
1000  struct GNUNET_SERVICE_Client *client,
1001  void *app_cls)
1002 {
1003  struct BobServiceSession *s = app_cls;
1004 
1006  "Client disconnected from us.\n");
1007  s->client = NULL;
1009 }
1010 
1011 
1019 static void
1020 run (void *cls,
1021  const struct GNUNET_CONFIGURATION_Handle *c,
1023 {
1024  cfg = c;
1025  /* We don't really do DLOG, so we can setup with very minimal resources */
1026  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1027  2 /* RAM */);
1028  my_cadet = GNUNET_CADET_connect (cfg);
1030  NULL);
1031  if (NULL == my_cadet)
1032  {
1034  _ ("Connect to CADET failed\n"));
1036  return;
1037  }
1038 }
1039 
1040 
1045  ("scalarproduct-bob",
1047  &run,
1050  NULL,
1051  GNUNET_MQ_hd_var_size (bob_client_message,
1053  struct BobComputationMessage,
1054  NULL),
1055  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
1058  NULL),
1060 
1061 
1062 /* end of gnunet-service-scalarproduct-ecc_bob.c */
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
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_CRYPTO_EccPoint prod_g_i_b_i
The product of the g_i^{b_i} values.
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
int in_destroy
Are we already in destroy_service_session()?
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:775
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
static int check_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
static void handle_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob&#39;s a client request message.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
Success, all elements have been sent (and received).
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
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
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
The other peer refused to do the operation with us, or something went wrong.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
static void handle_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us...
Opaque handle to the service.
Definition: cadet_api.c:38
uint32_t used_element_count
How many elements actually are used for the scalar product.
Handle to a service.
Definition: service.c:116
scalarproduct service P2P messages
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:99
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB.
Definition: scalarproduct.h:94
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
Operation is still active (never returned, used internally).
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
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1331
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_CADET_Port * port
Our open port.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
Option for set operations.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob&#39;s end.
static int check_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob&#39;s a client request message.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
static struct GNUNET_HashCode session_id
Opaque handle to a channel.
Definition: cadet.h:116
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
Client -> Bob.
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
int64_t value
a_i value, not disclosed to Bob.
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
Handle to a client that is connected to a service.
Definition: service.c:250
#define max(x, y)
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
Opaque handle to a set.
Definition: seti_api.c:39
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
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
Scalar Product API Message Types.
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Operation is still active (never returned, used internally).
Element stored in a set.
struct GNUNET_CADET_Channel * channel
The CADET channel.
uint16_t status
See PRISM_STATUS_*-constants.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
const void * data
Actual data of the element.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
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
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
GNUNET_SERVICE_MAIN("scalarproduct-bob", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(bob_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, struct BobComputationMessage, NULL), GNUNET_MQ_hd_var_size(bob_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
The product of the h_i^{b_i} values.
uint32_t contained_element_count
How many elements this individual message delivers (in NBO), always TWO.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA.
A 512-bit hashcode.
uint32_t total
How many elements will be supplied in total from the client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
Message handler for a specific message type.
Handle to an operation.
Definition: seti_api.c:105
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
unsigned char v[256/8]
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Message type passed from responding service Bob to responding service Alice to complete a request and...
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
An encrypted element key-value pair.
static void handle_alices_computation_request(void *cls, const struct EccServiceRequestMessage *msg)
Handle a request from Alice to calculate a scalarproduct with us (Bob).
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
uint32_t product_length
0 if no product attached
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
int64_t value
Value to multiply in scalar product, in NBO.
static int check_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Check a multipart-chunk of a request from another service to calculate a scalarproduct with us...
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static unsigned long long payload
How much data are we currently storing in the database?
Element should be delete from the result set of the local peer, i.e.
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
uint32_t element_count_contained
contained elements the vector in payload contains
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
static void handle_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
The identity of the host (wraps the signing key of the peer).
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
struct GNUNET_MessageHeader header
GNUNET message header.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
configuration data
Definition: configuration.c:84
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.
GNUNET_SETI_Status
Status for the result callback.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
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
A ECC scalar for use in point multiplications.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB
Client -> Bob multipart.
Opaque handle to a port.
Definition: cadet_api.c:79
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
uint32_t element_count_contained
contained elements the vector in payload contains
multipart messages following struct ComputationMessage
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:88
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
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.
Internal structure used to cache pre-calculated values for DLOG calculation.
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:808
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
Product of the h_i^{b_i}.
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
static void shutdown_task(void *cls)
Task run during shutdown.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
Product of the g_i^{b_i}.
#define LOG(kind,...)
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
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.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
uint16_t element_type
Application-specific element type.
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
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
#define GNUNET_free(ptr)
Wrapper around free.
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_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