GNUnet 0.21.1
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"
32#include "gnunet_applications.h"
33#include "gnunet_protocols.h"
35#include "gnunet_seti_service.h"
36#include "scalarproduct.h"
38#include "gnunet_constants.h"
39
40#define LOG(kind, ...) \
41 GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
42
48#define MAX_RESULT (1024 * 1024)
49
56#define MAX_RAM (1024)
57
62{
68 const struct GNUNET_HashCode *key;
69
73 int64_t value;
74};
75
76
82{
87
92
97
102
107
113
119
125
130
135
140
145
150 uint32_t total;
151
158
164
172
178};
179
180
184static const struct GNUNET_CONFIGURATION_Handle *cfg;
185
190
195
200
205
206
215static int
217 const struct GNUNET_HashCode *key,
218 void *value)
219{
221
222 GNUNET_free (e);
223 return GNUNET_OK;
224}
225
226
232static void
234{
235 if (GNUNET_YES == s->in_destroy)
236 return;
238 if (NULL != s->client)
239 {
240 struct GNUNET_SERVICE_Client *c = s->client;
241
242 s->client = NULL;
244 }
245 if (NULL != s->channel)
246 {
248 s->channel = NULL;
249 }
250 if (NULL != s->intersected_elements)
251 {
254 s);
256 s->intersected_elements = NULL;
257 }
258 if (NULL != s->intersection_listen)
259 {
261 s->intersection_listen = NULL;
262 }
263 if (NULL != s->intersection_op)
264 {
266 "Set intersection, op still ongoing!\n");
268 s->intersection_op = NULL;
269 }
270 if (NULL != s->intersection_set)
271 {
273 s->intersection_set = NULL;
274 }
275 if (NULL != s->sorted_elements)
276 {
278 s->sorted_elements = NULL;
279 }
280 GNUNET_free (s);
281}
282
283
290static void
292{
294 struct GNUNET_MQ_Envelope *e;
295
296 if (NULL == session->client_mq)
297 return; /* no client left to be notified */
298 GNUNET_log (
300 "Sending session-end notification with status %d to client for session %s\n",
301 session->status,
302 GNUNET_h2s (&session->session_id));
303 e = GNUNET_MQ_msg (msg,
305 msg->product_length = htonl (0);
306 msg->status = htonl (session->status);
307 GNUNET_MQ_send (session->client_mq,
308 e);
309}
310
311
318static void
320{
322 struct GNUNET_MQ_Envelope *e;
323 unsigned char *product_exported = NULL;
324 size_t product_length = 0;
325 int32_t range;
326 gcry_error_t rc;
327 gcry_mpi_t value;
328
329 if (INT_MAX == s->product)
330 {
331 GNUNET_break (0);
333 return;
334 }
335 value = gcry_mpi_new (32);
336 if (0 > s->product)
337 {
338 range = -1;
339 gcry_mpi_set_ui (value,
340 -s->product);
341 }
342 else if (0 < s->product)
343 {
344 range = 1;
345 gcry_mpi_set_ui (value,
346 s->product);
347 }
348 else
349 {
350 /* result is exactly zero */
351 range = 0;
352 }
353 if ( (0 != range) &&
354 (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
355 &product_exported,
356 &product_length,
357 value))))
358 {
360 "gcry_mpi_scan",
361 rc);
363 return;
364 }
365 gcry_mpi_release (value);
367 product_length,
370 msg->range = htonl (range);
371 msg->product_length = htonl (product_length);
372 if (NULL != product_exported)
373 {
374 GNUNET_memcpy (&msg[1],
375 product_exported,
376 product_length);
377 GNUNET_free (product_exported);
378 }
380 e);
382 "Sent result to client, session %s has ended!\n",
383 GNUNET_h2s (&s->session_id));
384}
385
386
396static void
398 const struct GNUNET_CADET_Channel *channel)
399{
400 struct AliceServiceSession *s = cls;
401
403 "Peer disconnected, terminating session %s with peer %s\n",
404 GNUNET_h2s (&s->session_id),
405 GNUNET_i2s (&s->peer));
406 s->channel = NULL;
408 {
409 /* We didn't get an answer yet, fail with error */
412 }
413}
414
415
423static void
425 const struct EccBobCryptodataMessage *msg)
426{
427 struct AliceServiceSession *s = cls;
428 uint32_t contained;
429
430 contained = ntohl (msg->contained_element_count);
431 if (2 != contained)
432 {
433 GNUNET_break_op (0);
435 return;
436 }
437 if (NULL == s->sorted_elements)
438 {
439 /* we're not ready yet, how can Bob be? */
440 GNUNET_break_op (0);
442 return;
443 }
444 if (s->total != s->client_received_element_count)
445 {
446 /* we're not ready yet, how can Bob be? */
447 GNUNET_break_op (0);
449 return;
450 }
452 "Received %u crypto values from Bob\n",
453 (unsigned int) contained);
454 GNUNET_CADET_receive_done (s->channel);
455 {
456 struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
457 struct GNUNET_CRYPTO_EccPoint g_ai_bi;
458
460 GNUNET_OK ==
461 GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
463 &g_i_b_i_a_inv));
465 GNUNET_OK ==
466 GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
467 &msg->prod_h_i_b_i,
468 &g_ai_bi));
470 &g_ai_bi);
471 if (INT_MAX == s->product)
472 {
473 /* result too big */
475 "Scalar product result out of range\n");
476 }
477 }
479}
480
481
490static int
492 const struct GNUNET_HashCode *key,
493 void *value)
494{
495 struct AliceServiceSession *s = cls;
497
499 e->value);
502 return GNUNET_OK;
503}
504
505
513static int
514element_cmp (const void *a,
515 const void *b)
516{
517 const struct MpiElement *ma = a;
518 const struct MpiElement *mb = b;
519
520 return GNUNET_CRYPTO_hash_cmp (ma->key,
521 mb->key);
522}
523
524
529#define ELEMENT_CAPACITY \
530 ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
531 - sizeof(struct EccAliceCryptodataMessage)) \
532 / sizeof(struct GNUNET_CRYPTO_EccPoint))
533
534
541static void
543{
545 struct GNUNET_MQ_Envelope *e;
547 struct GNUNET_CRYPTO_EccScalar r_ia;
548 struct GNUNET_CRYPTO_EccScalar r_ia_ai;
549 unsigned int off;
550 unsigned int todo_count;
551
554 struct MpiElement);
555 s->used_element_count = 0;
558 s);
560 "Finished intersection, %d items remain\n",
562 qsort (s->sorted_elements,
564 sizeof(struct MpiElement),
565 &element_cmp);
566 off = 0;
567 while (off < s->used_element_count)
568 {
569 todo_count = s->used_element_count - off;
570 if (todo_count > ELEMENT_CAPACITY)
571 todo_count = ELEMENT_CAPACITY;
573 "Sending %u/%u crypto values to Bob\n",
574 (unsigned int) todo_count,
575 (unsigned int) s->used_element_count);
576
577 e =
579 todo_count * 2
580 * sizeof(struct GNUNET_CRYPTO_EccPoint),
582 msg->contained_element_count = htonl (todo_count);
583 payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
584 for (unsigned int i = off; i < off + todo_count; i++)
585 {
586 struct GNUNET_CRYPTO_EccScalar r_i;
587 struct GNUNET_CRYPTO_EccPoint g_i;
588 struct GNUNET_CRYPTO_EccPoint h_i;
589
590 /* r_i = random() mod n */
592 /* g_i = g^{r_i} */
595 &g_i));
596 /* r_ia = r_i * a */
597 crypto_core_ed25519_scalar_mul (r_ia.v,
598 r_i.v,
599 my_privkey.v);
600 /* r_ia_ai = r_ia + a_i */
601 {
602 int64_t val = s->sorted_elements[i].value;
603 struct GNUNET_CRYPTO_EccScalar vali;
604
605 GNUNET_assert (INT64_MIN != val);
606 GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
607 &vali);
608 if (val > 0)
609 crypto_core_ed25519_scalar_add (r_ia_ai.v,
610 r_ia.v,
611 vali.v);
612 else
613 crypto_core_ed25519_scalar_sub (r_ia_ai.v,
614 r_ia.v,
615 vali.v);
616 }
617 /* h_i = g^{r_ia_ai} */
620 &h_i));
621 memcpy (&payload[(i - off) * 2],
622 &g_i,
623 sizeof (g_i));
624 memcpy (&payload[(i - off) * 2 + 1],
625 &h_i,
626 sizeof (h_i));
627 }
628 off += todo_count;
630 e);
631 }
632}
633
634
645static void
647 const struct GNUNET_SETI_Element *element,
648 uint64_t current_size,
650{
651 struct AliceServiceSession *s = cls;
653
654 switch (status)
655 {
657 /* this element has been removed from the set */
659 element->data);
660 GNUNET_assert (NULL != se);
662 "Intersection removed element with key %s and value %lld\n",
663 GNUNET_h2s (&se->key),
664 (long long) GNUNET_ntohll (se->value));
666 GNUNET_YES ==
668 element->data,
669 se));
670 GNUNET_free (se);
671 return;
673 s->intersection_op = NULL;
674 if (NULL != s->intersection_set)
675 {
677 s->intersection_set = NULL;
678 }
680 return;
682 /* unhandled status code */
683 LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
684 if (NULL != s->intersection_listen)
685 {
687 s->intersection_listen = NULL;
688 }
689 s->intersection_op = NULL;
690 if (NULL != s->intersection_set)
691 {
693 s->intersection_set = NULL;
694 }
697 return;
698
699 default:
700 GNUNET_break (0);
701 return;
702 }
703}
704
705
721static void
723 const struct GNUNET_PeerIdentity *other_peer,
724 const struct GNUNET_MessageHeader *context_msg,
726{
727 struct AliceServiceSession *s = cls;
728
730 "Received intersection request from %s!\n",
731 GNUNET_i2s (other_peer));
732 if (0 != GNUNET_memcmp (other_peer,
733 &s->peer))
734 {
735 GNUNET_break_op (0);
736 return;
737 }
738 s->intersection_op
740 (struct GNUNET_SETI_Option[]){ { 0 } },
742 s);
743 if (NULL == s->intersection_op)
744 {
745 GNUNET_break (0);
748 return;
749 }
750 if (GNUNET_OK !=
751 GNUNET_SETI_commit (s->intersection_op,
752 s->intersection_set))
753 {
754 GNUNET_break (0);
757 return;
758 }
759}
760
761
767static void
769{
770 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
771 GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
774 s),
776 };
778 struct GNUNET_MQ_Envelope *e;
779 struct GNUNET_HashCode set_sid;
780
782 sizeof(struct GNUNET_HashCode),
783 &set_sid);
785 "Creating new channel for session with key %s.\n",
786 GNUNET_h2s (&s->session_id));
788 s,
789 &s->peer,
790 &s->session_id,
791 NULL,
793 cadet_handlers);
794 if (NULL == s->channel)
795 {
798 return;
799 }
802 &set_sid,
804 s);
805 if (NULL == s->intersection_listen)
806 {
809 s->channel = NULL;
811 return;
812 }
813
814 e =
818 msg->session_id = s->session_id;
819 GNUNET_MQ_send (s->cadet_mq, e);
820}
821
822
831static int
833 void *cls,
835{
836 struct AliceServiceSession *s = cls;
837 uint32_t contained_count;
838 uint16_t msize;
839
840 msize = ntohs (msg->header.size);
841 contained_count = ntohl (msg->element_count_contained);
842 if ((msize !=
844 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
845 (0 == contained_count) ||
846 (s->total == s->client_received_element_count) ||
847 (s->total < s->client_received_element_count + contained_count))
848 {
849 GNUNET_break_op (0);
850 return GNUNET_SYSERR;
851 }
852 return GNUNET_OK;
853}
854
855
863static void
865 void *cls,
867{
868 struct AliceServiceSession *s = cls;
869 uint32_t contained_count;
870 const struct GNUNET_SCALARPRODUCT_Element *elements;
871 struct GNUNET_SETI_Element set_elem;
872 struct GNUNET_SCALARPRODUCT_Element *elem;
873
874 contained_count = ntohl (msg->element_count_contained);
875 s->client_received_element_count += contained_count;
876 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
877 for (uint32_t i = 0; i < contained_count; i++)
878 {
880 GNUNET_memcpy (elem,
881 &elements[i],
882 sizeof(struct GNUNET_SCALARPRODUCT_Element));
885 &elem->key,
886 elem,
888 {
889 GNUNET_break (0);
890 GNUNET_free (elem);
891 continue;
892 }
893 set_elem.data = &elem->key;
894 set_elem.size = sizeof(elem->key);
895 set_elem.element_type = 0;
896 GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
898 }
901 {
902 /* more to come */
904 "Received client multipart data, waiting for more!\n");
905 return;
906 }
907 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
909}
910
911
920static int
922 const struct AliceComputationMessage *msg)
923{
924 struct AliceServiceSession *s = cls;
925 uint16_t msize;
926 uint32_t total_count;
927 uint32_t contained_count;
928
929 if (NULL != s->intersected_elements)
930 {
931 /* only one concurrent session per client connection allowed,
932 simplifies logic a lot... */
933 GNUNET_break (0);
934 return GNUNET_SYSERR;
935 }
936 msize = ntohs (msg->header.size);
937 total_count = ntohl (msg->element_count_total);
938 contained_count = ntohl (msg->element_count_contained);
939 if ((0 == total_count) || (0 == contained_count) ||
940 (msize !=
941 (sizeof(struct AliceComputationMessage)
942 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
943 {
944 GNUNET_break_op (0);
945 return GNUNET_SYSERR;
946 }
947 return GNUNET_OK;
948}
949
950
958static void
960 const struct AliceComputationMessage *msg)
961{
962 struct AliceServiceSession *s = cls;
963 uint32_t contained_count;
964 uint32_t total_count;
965 const struct GNUNET_SCALARPRODUCT_Element *elements;
966 struct GNUNET_SETI_Element set_elem;
967 struct GNUNET_SCALARPRODUCT_Element *elem;
968
969 total_count = ntohl (msg->element_count_total);
970 contained_count = ntohl (msg->element_count_contained);
971 s->peer = msg->peer;
973 s->total = total_count;
974 s->client_received_element_count = contained_count;
975 s->session_id = msg->session_key;
976 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
979 GNUNET_YES);
981 for (uint32_t i = 0; i < contained_count; i++)
982 {
983 if (0 == GNUNET_ntohll (elements[i].value))
984 continue;
986 *elem = elements[i];
987 if (GNUNET_SYSERR ==
990 &elem->key,
991 elem,
993 {
994 /* element with same key encountered twice! */
995 GNUNET_break (0);
996 GNUNET_free (elem);
997 continue;
998 }
999 set_elem.data = &elem->key;
1000 set_elem.size = sizeof(elem->key);
1001 set_elem.element_type = 0;
1003 &set_elem,
1004 NULL,
1005 NULL);
1006 s->used_element_count++;
1007 }
1010 {
1011 /* wait for multipart msg */
1013 "Received partial client request, waiting for more!\n");
1014 return;
1015 }
1017 "Launching computation\n");
1019}
1020
1021
1028static void
1029shutdown_task (void *cls)
1030{
1032 "Shutting down, initiating cleanup.\n");
1033 // FIXME: we have to cut our connections to CADET first!
1034 if (NULL != my_cadet)
1035 {
1037 my_cadet = NULL;
1038 }
1039 if (NULL != edc)
1040 {
1042 edc = NULL;
1043 }
1044}
1045
1046
1057static void *
1059 struct GNUNET_SERVICE_Client *client,
1060 struct GNUNET_MQ_Handle *mq)
1061{
1062 struct AliceServiceSession *s;
1063
1064 s = GNUNET_new (struct AliceServiceSession);
1065 s->client = client;
1066 s->client_mq = mq;
1067 return s;
1068}
1069
1070
1081static void
1084 void *app_cls)
1085{
1086 struct AliceServiceSession *s = app_cls;
1087
1089 "Client %p disconnected from us.\n",
1090 client);
1091 s->client = NULL;
1092 s->client_mq = NULL;
1094}
1095
1096
1104static void
1105run (void *cls,
1106 const struct GNUNET_CONFIGURATION_Handle *c,
1108{
1109 cfg = c;
1111 MAX_RAM);
1112 /* Select a random 'a' value for Alice */
1116 if (NULL == my_cadet)
1117 {
1119 _ ("Connect to CADET failed\n"));
1121 return;
1122 }
1124 NULL);
1125}
1126
1127
1132 "scalarproduct-alice",
1134 &run,
1137 NULL,
1138 GNUNET_MQ_hd_var_size (alice_client_message,
1141 NULL),
1143 alice_client_message_multipart,
1146 NULL),
1148
1149
1150/* 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
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
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 * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
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.
#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:40
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.
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
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:872
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected channel.
Definition: cadet_api.c:1066
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
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:1015
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:221
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the 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.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ 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...
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.
#define GNUNET_log(kind,...)
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.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
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.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccScalar *r)
Generate a random value mod n.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
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_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:830
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_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#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:567
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:1340
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2484
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
@ 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:754
void GNUNET_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: seti_api.c:488
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
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:702
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
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
void GNUNET_SETI_listen_cancel(struct GNUNET_SETI_ListenHandle *lh)
Cancel the given listen operation.
Definition: seti_api.c:734
@ 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:178
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:116
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:87
Message handler for a specific message type.
Header for all communications.
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:246
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.