GNUnet 0.22.2
gnunet-service-scalarproduct_alice.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2013, 2014, 2017 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"
31#include "gnunet_protocols.h"
33#include "gnunet_seti_service.h"
34#include "scalarproduct.h"
36#include "gnunet_constants.h"
37
38#define LOG(kind, ...) \
39 GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
40
44struct MpiElement
45{
51 const struct GNUNET_HashCode *key;
52
56 gcry_mpi_t value;
57};
58
59
65{
70
75
80
85
90
96
102
108
113
118
123
128
133
138
143
147 gcry_mpi_t product;
148
153 uint32_t total;
154
160 uint32_t used_element_count;
161
167
173
181
186 int in_destroy;
187};
188
189
193static const struct GNUNET_CONFIGURATION_Handle *cfg;
194
199
204
208static gcry_mpi_t my_offset;
209
214
215
224static int
225free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
226{
228
229 GNUNET_free (e);
230 return GNUNET_OK;
231}
232
233
239static void
241{
242 if (GNUNET_YES == s->in_destroy)
243 return;
245 if (NULL != s->client)
246 {
247 struct GNUNET_SERVICE_Client *c = s->client;
248
249 s->client = NULL;
251 }
252 if (NULL != s->channel)
253 {
255 s->channel = NULL;
256 }
257 if (NULL != s->intersected_elements)
258 {
261 s);
263 s->intersected_elements = NULL;
264 }
265 if (NULL != s->intersection_listen)
266 {
268 s->intersection_listen = NULL;
269 }
270 if (NULL != s->intersection_op)
271 {
273 s->intersection_op = NULL;
274 }
275 if (NULL != s->intersection_set)
276 {
278 s->intersection_set = NULL;
279 }
280 if (NULL != s->sorted_elements)
281 {
282 for (unsigned int i = 0; i < s->used_element_count; i++)
283 gcry_mpi_release (s->sorted_elements[i].value);
285 s->sorted_elements = NULL;
286 }
287 if (NULL != s->r)
288 {
289 GNUNET_free (s->r);
290 s->r = NULL;
291 }
292 if (NULL != s->r_prime)
293 {
294 GNUNET_free (s->r_prime);
295 s->r_prime = NULL;
296 }
297 if (NULL != s->product)
298 {
299 gcry_mpi_release (s->product);
300 s->product = NULL;
301 }
302 GNUNET_free (s);
303}
304
305
312static void
314{
316 struct GNUNET_MQ_Envelope *e;
317
318 if (NULL == session->client_mq)
319 return; /* no client left to be notified */
320 GNUNET_log (
322 "Sending session-end notification with status %d to client for session %s\n",
323 session->status,
324 GNUNET_h2s (&session->session_id));
326 msg->product_length = htonl (0);
327 msg->status = htonl (session->status);
328 GNUNET_MQ_send (session->client_mq, e);
329}
330
331
338static void
340{
342 struct GNUNET_MQ_Envelope *e;
343 unsigned char *product_exported = NULL;
344 size_t product_length = 0;
345 int32_t range;
346 gcry_error_t rc;
347 int sign;
348 gcry_mpi_t value;
349
350 if (NULL == s->product)
351 {
352 GNUNET_break (0);
354 return;
355 }
356 value = gcry_mpi_new (0);
357 sign = gcry_mpi_cmp_ui (s->product, 0);
358 if (0 > sign)
359 {
360 range = -1;
361 gcry_mpi_sub (value, value, s->product);
362 }
363 else if (0 < sign)
364 {
365 range = 1;
366 gcry_mpi_add (value, value, s->product);
367 }
368 else
369 {
370 /* result is exactly zero */
371 range = 0;
372 }
373 gcry_mpi_release (s->product);
374 s->product = NULL;
375
376 if ((0 != range) && (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
377 &product_exported,
378 &product_length,
379 value))))
380 {
381 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
383 return;
384 }
385 gcry_mpi_release (value);
387 product_length,
390 msg->range = htonl (range);
391 msg->product_length = htonl (product_length);
392 if (NULL != product_exported)
393 {
394 GNUNET_memcpy (&msg[1], product_exported, product_length);
395 GNUNET_free (product_exported);
396 }
399 "Sent result to client, session %s has ended!\n",
400 GNUNET_h2s (&s->session_id));
401}
402
403
413static void
414cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
415{
416 struct AliceServiceSession *s = cls;
417
419 "Peer disconnected, terminating session %s with peer %s\n",
420 GNUNET_h2s (&s->session_id),
421 GNUNET_i2s (&s->peer));
423 {
424 /* We didn't get an answer yet, fail with error */
427 }
428 s->channel = NULL;
429}
430
431
439static gcry_mpi_t
441 uint32_t length)
442{
443 gcry_mpi_t elem;
444 gcry_mpi_t sum;
445 uint32_t i;
446
447 GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
448 GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
449 for (i = 0; i < length; i++)
450 {
451 gcry_mpi_mul (elem, vector[i].value, vector[i].value);
452 gcry_mpi_add (sum, sum, elem);
453 }
454 gcry_mpi_release (elem);
455 return sum;
456}
457
458
466static gcry_mpi_t
467compute_square_sum (const gcry_mpi_t *vector, uint32_t length)
468{
469 gcry_mpi_t elem;
470 gcry_mpi_t sum;
471 uint32_t i;
472
473 GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
474 GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
475 for (i = 0; i < length; i++)
476 {
477 gcry_mpi_mul (elem, vector[i], vector[i]);
478 gcry_mpi_add (sum, sum, elem);
479 }
480 gcry_mpi_release (elem);
481 return sum;
482}
483
484
491static gcry_mpi_t
493{
494 uint32_t count;
495 gcry_mpi_t t;
496 gcry_mpi_t u;
497 gcry_mpi_t u_prime;
498 gcry_mpi_t p;
499 gcry_mpi_t p_prime;
500 gcry_mpi_t tmp;
501 gcry_mpi_t r[session->used_element_count];
502 gcry_mpi_t r_prime[session->used_element_count];
503 gcry_mpi_t s;
504 gcry_mpi_t s_prime;
505 unsigned int i;
506
507 count = session->used_element_count;
508 // due to the introduced static offset S, we now also have to remove this
509 // from the E(a_pi)(+)E(-b_pi-r_pi) and E(a_qi)(+)E(-r_qi) twice each,
510 // the result is E((S + a_pi) + (S -b_pi-r_pi)) and E(S + a_qi + S - r_qi)
511 for (i = 0; i < count; i++)
512 {
513 r[i] = gcry_mpi_new (0);
515 &my_pubkey,
516 &session->r[i],
517 r[i]);
518 gcry_mpi_sub (r[i], r[i], my_offset);
519 gcry_mpi_sub (r[i], r[i], my_offset);
520 r_prime[i] = gcry_mpi_new (0);
522 &my_pubkey,
523 &session->r_prime[i],
524 r_prime[i]);
525 gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
526 gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
527 }
528
529 // calculate t = sum(ai)
531 // calculate U
532 u = gcry_mpi_new (0);
533 tmp = compute_square_sum (r, count);
534 gcry_mpi_sub (u, u, tmp);
535 gcry_mpi_release (tmp);
536
537 // calculate U'
538 u_prime = gcry_mpi_new (0);
539 tmp = compute_square_sum (r_prime, count);
540 gcry_mpi_sub (u_prime, u_prime, tmp);
541
542 GNUNET_assert (p = gcry_mpi_new (0));
543 GNUNET_assert (p_prime = gcry_mpi_new (0));
544 GNUNET_assert (s = gcry_mpi_new (0));
545 GNUNET_assert (s_prime = gcry_mpi_new (0));
546
547 // compute P
550 &my_pubkey,
551 &session->s_prime,
552 s_prime);
553
554 // compute P
555 gcry_mpi_add (p, s, t);
556 gcry_mpi_add (p, p, u);
557
558 // compute P'
559 gcry_mpi_add (p_prime, s_prime, t);
560 gcry_mpi_add (p_prime, p_prime, u_prime);
561
562 gcry_mpi_release (t);
563 gcry_mpi_release (u);
564 gcry_mpi_release (u_prime);
565 gcry_mpi_release (s);
566 gcry_mpi_release (s_prime);
567
568 // compute product
569 gcry_mpi_sub (p, p, p_prime);
570 gcry_mpi_release (p_prime);
571 tmp = gcry_mpi_set_ui (tmp, 2);
572 gcry_mpi_div (p, NULL, p, tmp, 0);
573
574 gcry_mpi_release (tmp);
575 for (i = 0; i < count; i++)
576 {
577 gcry_mpi_release (session->sorted_elements[i].value);
578 gcry_mpi_release (r[i]);
579 gcry_mpi_release (r_prime[i]);
580 }
581 GNUNET_free (session->sorted_elements);
582 session->sorted_elements = NULL;
583 GNUNET_free (session->r);
584 session->r = NULL;
585 GNUNET_free (session->r_prime);
586 session->r_prime = NULL;
587
588 return p;
589}
590
591
601static int
603 void *cls,
605{
606 struct AliceServiceSession *s = cls;
607 uint32_t contained;
608 size_t msg_size;
609 size_t required_size;
610
611 msg_size = ntohs (msg->header.size);
612 contained = ntohl (msg->contained_element_count);
613 required_size =
614 sizeof(struct BobCryptodataMultipartMessage)
615 + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
616 if ((required_size != msg_size) ||
618 {
619 GNUNET_break (0);
620 return GNUNET_SYSERR;
621 }
622 return GNUNET_OK;
623}
624
625
633static void
635 void *cls,
637{
638 struct AliceServiceSession *s = cls;
640 size_t i;
641 uint32_t contained;
642
643 contained = ntohl (msg->contained_element_count);
645 "Received %u additional crypto values from Bob\n",
646 (unsigned int) contained);
647
648 payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
649 /* Convert each k[][perm] to its MPI_value */
650 for (i = 0; i < contained; i++)
651 {
653 &payload[2 * i],
654 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
656 &payload[2 * i],
657 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
658 }
659 s->cadet_received_element_count += contained;
662 return; /* more to come */
663
666}
667
668
678static int
680 const struct BobCryptodataMessage *msg)
681{
682 struct AliceServiceSession *s = cls;
683 uint32_t contained;
684 uint16_t msg_size;
685 size_t required_size;
686
687 msg_size = ntohs (msg->header.size);
688 contained = ntohl (msg->contained_element_count);
689 required_size =
690 sizeof(struct BobCryptodataMessage)
691 + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
692 + 2 * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
693 if ((msg_size != required_size) || (contained > UINT16_MAX) ||
694 (s->used_element_count < contained))
695 {
696 GNUNET_break_op (0);
697 return GNUNET_SYSERR;
698 }
699 if (NULL == s->sorted_elements)
700 {
701 /* we're not ready yet, how can Bob be? */
702 GNUNET_break_op (0);
703 return GNUNET_SYSERR;
704 }
706 {
707 /* we're not ready yet, how can Bob be? */
708 GNUNET_break_op (0);
709 return GNUNET_SYSERR;
710 }
711 return GNUNET_OK;
712}
713
714
722static void
724 const struct BobCryptodataMessage *msg)
725{
726 struct AliceServiceSession *s = cls;
728 uint32_t i;
729 uint32_t contained;
730
731 contained = ntohl (msg->contained_element_count);
733 "Received %u crypto values from Bob\n",
734 (unsigned int) contained);
735 payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
736 GNUNET_memcpy (&s->s,
737 &payload[0],
738 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
740 &payload[1],
741 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
742 payload = &payload[2];
743
748 for (i = 0; i < contained; i++)
749 {
750 GNUNET_memcpy (&s->r[i],
751 &payload[2 * i],
752 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
753 GNUNET_memcpy (&s->r_prime[i],
754 &payload[2 * i + 1],
755 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
756 }
757 s->cadet_received_element_count = contained;
759
761 {
762 /* More to come */
763 return;
764 }
767}
768
769
778static int
779copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
780{
781 struct AliceServiceSession *s = cls;
783 gcry_mpi_t mval;
784 int64_t val;
785
786 mval = gcry_mpi_new (0);
787 val = (int64_t) GNUNET_ntohll (e->value);
788 if (0 > val)
789 gcry_mpi_sub_ui (mval, mval, -val);
790 else
791 gcry_mpi_add_ui (mval, mval, val);
795 return GNUNET_OK;
796}
797
798
806static int
807element_cmp (const void *a, const void *b)
808{
809 const struct MpiElement *ma = a;
810 const struct MpiElement *mb = b;
811
812 return GNUNET_CRYPTO_hash_cmp (ma->key, mb->key);
813}
814
815
820#define ELEMENT_CAPACITY \
821 ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
822 - sizeof(struct AliceCryptodataMessage)) \
823 / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext))
824
825
832static void
834{
836 struct GNUNET_MQ_Envelope *e;
838 unsigned int i;
839 uint32_t todo_count;
840 gcry_mpi_t a;
841 uint32_t off;
842
845 * sizeof(struct MpiElement));
846 s->used_element_count = 0;
849 s);
851 "Finished intersection, %d items remain\n",
853 qsort (s->sorted_elements,
855 sizeof(struct MpiElement),
856 &element_cmp);
857 off = 0;
858 while (off < s->used_element_count)
859 {
860 todo_count = s->used_element_count - off;
861 if (todo_count > ELEMENT_CAPACITY)
862 todo_count = ELEMENT_CAPACITY;
864 "Sending %u/%u crypto values to Bob\n",
865 (unsigned int) todo_count,
866 (unsigned int) s->used_element_count);
867
868 e =
870 todo_count
871 * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
873 msg->contained_element_count = htonl (todo_count);
875 a = gcry_mpi_new (0);
876 for (i = off; i < off + todo_count; i++)
877 {
878 gcry_mpi_add (a, s->sorted_elements[i].value, my_offset);
880 3 ==
882 }
883 gcry_mpi_release (a);
884 off += todo_count;
885 GNUNET_MQ_send (s->cadet_mq, e);
886 }
887}
888
889
900static void
902 const struct GNUNET_SETI_Element *element,
903 uint64_t current_size,
905{
906 struct AliceServiceSession *s = cls;
908
909 switch (status)
910 {
912 /* this element has been removed from the set */
914 element->data);
915 GNUNET_assert (NULL != se);
917 "Intersection removed element with key %s and value %lld\n",
918 GNUNET_h2s (&se->key),
919 (long long) GNUNET_ntohll (se->value));
921 GNUNET_YES ==
923 element->data,
924 se));
925 GNUNET_free (se);
926 return;
927
929 s->intersection_op = NULL;
930 if (NULL != s->intersection_set)
931 {
933 s->intersection_set = NULL;
934 }
936 return;
938 /* unhandled status code */
939 LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
940 if (NULL != s->intersection_listen)
941 {
943 s->intersection_listen = NULL;
944 }
945 s->intersection_op = NULL;
946 if (NULL != s->intersection_set)
947 {
949 s->intersection_set = NULL;
950 }
953 return;
954
955 default:
956 GNUNET_break (0);
957 return;
958 }
959}
960
961
977static void
979 const struct GNUNET_PeerIdentity *other_peer,
980 const struct GNUNET_MessageHeader *context_msg,
982{
983 struct AliceServiceSession *s = cls;
984
985 if (0 != GNUNET_memcmp (other_peer, &s->peer))
986 {
987 GNUNET_break_op (0);
988 return;
989 }
990 s->intersection_op = GNUNET_SETI_accept (request,
991 (struct
992 GNUNET_SETI_Option[]){ { 0 } },
994 s);
995 if (NULL == s->intersection_op)
996 {
997 GNUNET_break (0);
1000 return;
1001 }
1002 if (GNUNET_OK != GNUNET_SETI_commit (s->intersection_op, s->intersection_set))
1003 {
1004 GNUNET_break (0);
1007 return;
1008 }
1009}
1010
1011
1017static void
1019{
1020 struct GNUNET_MQ_MessageHandler cadet_handlers[] =
1021 { GNUNET_MQ_hd_var_size (bobs_cryptodata_message,
1023 struct BobCryptodataMessage,
1024 s),
1026 bobs_cryptodata_multipart,
1029 s),
1031 struct ServiceRequestMessage *msg;
1032 struct GNUNET_MQ_Envelope *e;
1033
1035 "Creating new channel for session with key %s.\n",
1036 GNUNET_h2s (&s->session_id));
1038 s,
1039 &s->peer,
1040 &s->session_id,
1041 NULL,
1043 cadet_handlers);
1044 if (NULL == s->channel)
1045 {
1048 return;
1049 }
1052 &s->session_id,
1054 s);
1055 if (NULL == s->intersection_listen)
1056 {
1059 s->channel = NULL;
1061 return;
1062 }
1063
1064 e = GNUNET_MQ_msg (msg,
1066 msg->session_id = s->session_id;
1067 msg->public_key = my_pubkey;
1068 GNUNET_MQ_send (s->cadet_mq, e);
1069}
1070
1071
1080static int
1082 void *cls,
1084{
1085 struct AliceServiceSession *s = cls;
1086 uint32_t contained_count;
1087 uint16_t msize;
1088
1089 msize = ntohs (msg->header.size);
1090 contained_count = ntohl (msg->element_count_contained);
1091 if ((msize !=
1093 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
1094 (0 == contained_count) ||
1095 (s->total == s->client_received_element_count) ||
1096 (s->total < s->client_received_element_count + contained_count))
1097 {
1098 GNUNET_break_op (0);
1099 return GNUNET_SYSERR;
1100 }
1101 return GNUNET_OK;
1102}
1103
1104
1112static void
1114 void *cls,
1116{
1117 struct AliceServiceSession *s = cls;
1118 uint32_t contained_count;
1119 const struct GNUNET_SCALARPRODUCT_Element *elements;
1120 struct GNUNET_SETI_Element set_elem;
1121 struct GNUNET_SCALARPRODUCT_Element *elem;
1122
1123 contained_count = ntohl (msg->element_count_contained);
1124 s->client_received_element_count += contained_count;
1125 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1126 for (uint32_t i = 0; i < contained_count; i++)
1127 {
1129 GNUNET_memcpy (elem,
1130 &elements[i],
1131 sizeof(struct GNUNET_SCALARPRODUCT_Element));
1134 &elem->key,
1135 elem,
1137 {
1138 GNUNET_break (0);
1139 GNUNET_free (elem);
1140 continue;
1141 }
1142 set_elem.data = &elem->key;
1143 set_elem.size = sizeof(elem->key);
1144 set_elem.element_type = 0;
1145 GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
1146 s->used_element_count++;
1147 }
1150 {
1151 /* more to come */
1152 return;
1153 }
1155}
1156
1157
1166static int
1168 const struct AliceComputationMessage *msg)
1169{
1170 struct AliceServiceSession *s = cls;
1171 uint16_t msize;
1172 uint32_t total_count;
1173 uint32_t contained_count;
1174
1175 if (NULL != s->intersected_elements)
1176 {
1177 /* only one concurrent session per client connection allowed,
1178 simplifies logic a lot... */
1179 GNUNET_break (0);
1180 return GNUNET_SYSERR;
1181 }
1182 msize = ntohs (msg->header.size);
1183 total_count = ntohl (msg->element_count_total);
1184 contained_count = ntohl (msg->element_count_contained);
1185 if ((0 == total_count) || (0 == contained_count) ||
1186 (msize !=
1187 (sizeof(struct AliceComputationMessage)
1188 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
1189 {
1190 GNUNET_break_op (0);
1191 return GNUNET_SYSERR;
1192 }
1193 return GNUNET_OK;
1194}
1195
1196
1204static void
1206 const struct AliceComputationMessage *msg)
1207{
1208 struct AliceServiceSession *s = cls;
1209 uint32_t contained_count;
1210 uint32_t total_count;
1211 const struct GNUNET_SCALARPRODUCT_Element *elements;
1212 struct GNUNET_SETI_Element set_elem;
1213 struct GNUNET_SCALARPRODUCT_Element *elem;
1214
1215 total_count = ntohl (msg->element_count_total);
1216 contained_count = ntohl (msg->element_count_contained);
1217 s->peer = msg->peer;
1219 s->total = total_count;
1220 s->client_received_element_count = contained_count;
1221 s->session_id = msg->session_key;
1222 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1226
1227 for (uint32_t i = 0; i < contained_count; i++)
1228 {
1229 if (0 == GNUNET_ntohll (elements[i].value))
1230 continue;
1232 GNUNET_memcpy (elem,
1233 &elements[i],
1234 sizeof(struct GNUNET_SCALARPRODUCT_Element));
1237 &elem->key,
1238 elem,
1240 {
1241 /* element with same key encountered twice! */
1242 GNUNET_break (0);
1243 GNUNET_free (elem);
1244 continue;
1245 }
1246 set_elem.data = &elem->key;
1247 set_elem.size = sizeof(elem->key);
1248 set_elem.element_type = 0;
1250 &set_elem,
1251 NULL,
1252 NULL);
1253 s->used_element_count++;
1254 }
1257 {
1258 /* wait for multipart msg */
1259 return;
1260 }
1262}
1263
1264
1270static void
1271shutdown_task (void *cls)
1272{
1273 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down, initiating cleanup.\n");
1274 // FIXME: we have to cut our connections to CADET first!
1275 if (NULL != my_cadet)
1276 {
1278 my_cadet = NULL;
1279 }
1280}
1281
1282
1293static void *
1295 struct GNUNET_SERVICE_Client *client,
1296 struct GNUNET_MQ_Handle *mq)
1297{
1298 struct AliceServiceSession *s;
1299
1300 s = GNUNET_new (struct AliceServiceSession);
1301 s->client = client;
1302 s->client_mq = mq;
1303 return s;
1304}
1305
1306
1317static void
1320 void *app_cls)
1321{
1322 struct AliceServiceSession *s = app_cls;
1323
1325 "Client %p disconnected from us.\n",
1326 client);
1327 s->client = NULL;
1328 s->client_mq = NULL;
1330}
1331
1332
1340static void
1341run (void *cls,
1342 const struct GNUNET_CONFIGURATION_Handle *c,
1344{
1345 cfg = c;
1346 /*
1347 offset has to be sufficiently small to allow computation of:
1348 m1+m2 mod n == (S + a) + (S + b) mod n,
1349 if we have more complex operations, this factor needs to be lowered */
1350 my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
1351 gcry_mpi_set_bit (my_offset, GNUNET_CRYPTO_PAILLIER_BITS / 3);
1355 if (NULL == my_cadet)
1356 {
1357 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Connect to CADET failed\n"));
1359 return;
1360 }
1361}
1362
1363
1369 "scalarproduct-alice",
1371 &run,
1374 NULL,
1375 GNUNET_MQ_hd_var_size (alice_client_message,
1378 NULL),
1380 alice_client_message_multipart,
1383 NULL),
1385
1386
1387/* end of gnunet-service-scalarproduct_alice.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static mp_limb_t u[(((256)+GMP_NUMB_BITS - 1)/GMP_NUMB_BITS)]
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 void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
Service's own private key.
static int check_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice's client request message.
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_bobs_cryptodata_multipart(void *cls, const struct BobCryptodataMultipartMessage *msg)
Check a multipart chunk of a response we got from another service we wanted to calculate a scalarprod...
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 handle_bobs_cryptodata_message(void *cls, const struct BobCryptodataMessage *msg)
Handle a response we got from another service we wanted to calculate a scalarproduct with.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
static gcry_mpi_t compute_square_sum_mpi_elements(const struct MpiElement *vector, uint32_t length)
Computes the square sum over a vector of a given length.
static void handle_bobs_cryptodata_multipart(void *cls, const struct BobCryptodataMultipartMessage *msg)
Handle a multipart chunk of a response we got from another service we wanted to calculate a scalarpro...
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
GNUNET_SERVICE_MAIN(GNUNET_OS_project_data_gnunet(), "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 void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
static int check_bobs_cryptodata_message(void *cls, const struct BobCryptodataMessage *msg)
Check a response we got from another service we wanted to calculate a scalarproduct with.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static void handle_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice's client request message.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
static gcry_mpi_t compute_square_sum(const gcry_mpi_t *vector, uint32_t length)
Computes the square sum over a vector of a given length.
static gcry_mpi_t compute_scalar_product(struct AliceServiceSession *session)
Compute our scalar product, done by Alice.
#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.
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
Service's own public key.
static gcry_mpi_t my_offset
Service's offset for values that could possibly be negative but are plaintext for encryption.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:40
static struct GNUNET_SCHEDULER_Task * t
Main task.
CADET service; establish channels to distant peers.
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:897
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:875
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:833
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:1081
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:777
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:1030
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:218
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...
#define GNUNET_log(kind,...)
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
int GNUNET_CRYPTO_paillier_encrypt(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const gcry_mpi_t m, int desired_ops, struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
Encrypt a plaintext with a paillier public key.
void GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
Create a freshly generated paillier public key.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void GNUNET_CRYPTO_paillier_decrypt(const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key, const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext, gcry_mpi_t m)
Decrypt a paillier ciphertext with a private key.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ 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_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#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:61
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:76
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_gnunet(void)
Return default project data used by 'libgnunetutil' for GNUnet.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
Alice -> Bob SP crypto-data (after intersection)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA
Bob -> Alice SP crypto-data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE
Client -> Alice multipart.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
Alice -> Bob session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE
Client -> Alice.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART
Bob -> Alice SP crypto-data multipart.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
@ GNUNET_SCALARPRODUCT_STATUS_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:1339
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2418
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2389
@ 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:179
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
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection).
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.
gcry_mpi_t product
The computed scalar.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob's permutation p of R.
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
uint32_t cadet_received_element_count
Already transferred elements from Bob to us.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob's permutation q of R.
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.
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob's "s'".
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Message type passed from responding service Bob to responding service Alice to complete a request and...
Multipart Message type passed between to supply additional elements for the peer.
Message type passed from service client to finalize a session as requester or responder.
multipart messages following struct ComputationMessage
Opaque handle to a channel.
Definition: cadet.h:116
Opaque handle to the service.
Definition: cadet_api.c:39
Internal representation of the hash map.
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:249
Handle to a service.
Definition: service.c:116
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.
gcry_mpi_t value
Value represented (a).
Message type passed from requesting service Alice to responding service Bob to initiate a request and...