GNUnet 0.21.1
gnunet-service-scalarproduct_bob.c File Reference

scalarproduct service implementation More...

#include "platform.h"
#include <limits.h>
#include <gcrypt.h>
#include "gnunet_util_lib.h"
#include "gnunet_core_service.h"
#include "gnunet_cadet_service.h"
#include "gnunet_applications.h"
#include "gnunet_protocols.h"
#include "gnunet_scalarproduct_service.h"
#include "gnunet_seti_service.h"
#include "scalarproduct.h"
#include "gnunet-service-scalarproduct.h"
#include "gnunet_constants.h"
Include dependency graph for gnunet-service-scalarproduct_bob.c:

Go to the source code of this file.

Data Structures

struct  MpiElement
 An encrypted element key-value pair. More...
 
struct  BobServiceSession
 A scalarproduct session which tracks an offer for a multiplication service by a local client. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
 
#define ELEMENT_CAPACITY
 Maximum count of elements we can put into a multipart message. More...
 

Functions

static int free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Callback used to free the elements in the map. More...
 
static void destroy_service_session (struct BobServiceSession *s)
 Destroy session state, we are done with it. More...
 
static void prepare_client_end_notification (struct BobServiceSession *session)
 Notify the client that the session has succeeded or failed. More...
 
static void cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
static void bob_cadet_done_cb (void *cls)
 MQ finished giving our last message to CADET, now notify the client that we are finished. More...
 
static void transmit_bobs_cryptodata_message_multipart (struct BobServiceSession *s)
 Send a multipart chunk of a service response from Bob to Alice. More...
 
static void transmit_bobs_cryptodata_message (struct BobServiceSession *s)
 Bob generates the response message to be sent to Alice after computing the values (1), (2), S and S'. More...
 
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. More...
 
static int compute_service_response (struct BobServiceSession *session)
 Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) otimes E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$. More...
 
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. More...
 
static int element_cmp (const void *a, const void *b)
 Compare two struct MpiValues by key for sorting. More...
 
static void transmit_cryptographic_reply (struct BobServiceSession *s)
 Intersection operation and receiving data via CADET from Alice are both done, compute and transmit our reply via CADET. More...
 
static int check_alices_cryptodata_message (void *cls, const struct AliceCryptodataMessage *msg)
 Check a multipart-chunk of a request from another service to calculate a scalarproduct with us. More...
 
static void handle_alices_cryptodata_message (void *cls, const struct AliceCryptodataMessage *msg)
 Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us. More...
 
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. More...
 
static void start_intersection (struct BobServiceSession *s)
 We've paired up a client session with an incoming CADET request. More...
 
static void handle_alices_computation_request (void *cls, const struct ServiceRequestMessage *msg)
 Handle a request from Alice to calculate a scalarproduct with us (Bob). More...
 
static void * cb_channel_incoming (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
 Function called for inbound channels on Bob's end. More...
 
static int check_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static void handle_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static int check_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void handle_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 A client connected. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
 A client disconnected. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initialization of the program and message handlers. More...
 
 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. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 GNUnet configuration handle. More...
 
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
 Service's own public key. More...
 
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
 Service's own private key. More...
 
static gcry_mpi_t my_offset
 Service's offset for values that could possibly be negative but are plaintext for encryption. More...
 
static struct GNUNET_CADET_Handlemy_cadet
 Handle to the CADET service. More...
 

Detailed Description

scalarproduct service implementation

Author
Christian M. Fuchs
Christian Grothoff

Definition in file gnunet-service-scalarproduct_bob.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)

Definition at line 40 of file gnunet-service-scalarproduct_bob.c.

◆ ELEMENT_CAPACITY

#define ELEMENT_CAPACITY
Value:
- sizeof(struct BobCryptodataMultipartMessage)) \
/ sizeof(struct \
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
Multipart Message type passed between to supply additional elements for the peer.

Maximum count of elements we can put into a multipart message.

Definition at line 400 of file gnunet-service-scalarproduct_bob.c.

Function Documentation

◆ free_element_cb()

static int free_element_cb ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Callback used to free the elements in the map.

Parameters
clsNULL
keykey of the element
valuethe value to free

Definition at line 240 of file gnunet-service-scalarproduct_bob.c.

243{
244 struct GNUNET_SCALARPRODUCT_Element *element = value;
245
246 GNUNET_free (element);
247 return GNUNET_OK;
248}
static char * value
Value of the record to add/remove.
@ GNUNET_OK
#define GNUNET_free(ptr)
Wrapper around free.
An element key-value pair for scalarproduct.

References GNUNET_free, GNUNET_OK, and value.

Referenced by destroy_service_session().

Here is the caller graph for this function:

◆ destroy_service_session()

static void destroy_service_session ( struct BobServiceSession s)
static

Destroy session state, we are done with it.

Parameters
sessionthe session to free elements from

Definition at line 257 of file gnunet-service-scalarproduct_bob.c.

258{
259 unsigned int i;
260
261 if (GNUNET_YES == s->in_destroy)
262 return;
264 if (NULL != s->client)
265 {
266 struct GNUNET_SERVICE_Client *c = s->client;
267
268 s->client = NULL;
270 }
271 if (NULL != s->intersected_elements)
272 {
275 NULL);
277 s->intersected_elements = NULL;
278 }
279 if (NULL != s->intersection_op)
280 {
282 s->intersection_op = NULL;
283 }
284 if (NULL != s->intersection_set)
285 {
287 s->intersection_set = NULL;
288 }
289 if (NULL != s->e_a)
290 {
291 GNUNET_free (s->e_a);
292 s->e_a = NULL;
293 }
294 if (NULL != s->sorted_elements)
295 {
296 for (i = 0; i < s->used_element_count; i++)
297 gcry_mpi_release (s->sorted_elements[i].value);
299 s->sorted_elements = NULL;
300 }
301 if (NULL != s->r)
302 {
303 GNUNET_free (s->r);
304 s->r = NULL;
305 }
306 if (NULL != s->r_prime)
307 {
308 GNUNET_free (s->r_prime);
309 s->r_prime = NULL;
310 }
311 if (NULL != s->port)
312 {
314 s->port = NULL;
315 }
316 if (NULL != s->channel)
317 {
319 s->channel = NULL;
320 }
321 GNUNET_free (s);
322}
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
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_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
@ GNUNET_YES
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_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: seti_api.c:488
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob's permutation q of R.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value'd elements transmitted to us.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CRYPTO_PaillierCiphertext * e_a
E(ai)(Bob) after applying the mask.
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob's permutation p of R.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
int in_destroy
Are we already in destroy_service_session()?
Handle to a client that is connected to a service.
Definition: service.c:246
int64_t value
a_i value, not disclosed to Bob.

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::e_a, free_element_cb(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_SETI_destroy(), GNUNET_SETI_operation_cancel(), GNUNET_YES, BobServiceSession::in_destroy, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, BobServiceSession::port, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, and MpiElement::value.

Referenced by cb_channel_destruction(), and client_disconnect_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ prepare_client_end_notification()

static void prepare_client_end_notification ( struct BobServiceSession session)
static

Notify the client that the session has succeeded or failed.

This message gets sent to Bob's client if the operation completed or Alice disconnected.

Parameters
sessionthe associated client session to fail or succeed

Definition at line 333 of file gnunet-service-scalarproduct_bob.c.

334{
336 struct GNUNET_MQ_Envelope *e;
337
338 if (NULL == session->client_mq)
339 return; /* no client left to be notified */
341 "Sending session-end notification with status %d to client for session %s\n",
342 session->status,
343 GNUNET_h2s (&session->session_id));
344 e = GNUNET_MQ_msg (msg,
346 msg->range = 0;
347 msg->product_length = htonl (0);
348 msg->status = htonl (session->status);
349 GNUNET_MQ_send (session->client_mq,
350 e);
351}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_log(kind,...)
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
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_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
Message type passed from service client to finalize a session as requester or responder.

References BobServiceSession::client_mq, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), msg, BobServiceSession::session_id, and BobServiceSession::status.

Referenced by bob_cadet_done_cb(), cb_channel_destruction(), and cb_intersection_element_removed().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cb_channel_destruction()

static void cb_channel_destruction ( void *  cls,
const struct GNUNET_CADET_Channel channel 
)
static

Function called whenever a channel is destroyed.

Should clean up any associated state.

It must NOT call GNUNET_CADET_channel_destroy() on the channel.

Parameters
clsthe struct BobServiceSession
channelconnection to the other end (henceforth invalid)

Definition at line 364 of file gnunet-service-scalarproduct_bob.c.

366{
367 struct BobServiceSession *s = cls;
368
370 "Peer disconnected, terminating session %s with peer %s\n",
371 GNUNET_h2s (&s->session_id),
372 GNUNET_i2s (&s->peer));
374 {
377 }
378 s->channel = NULL;
380}
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_SCALARPRODUCT_STATUS_ACTIVE
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_FAILURE
We encountered some error.
A scalarproduct session which tracks an offer for a multiplication service by a local client.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".

References destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SCALARPRODUCT_STATUS_FAILURE, prepare_client_end_notification(), and BobServiceSession::s.

Referenced by handle_bob_client_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bob_cadet_done_cb()

static void bob_cadet_done_cb ( void *  cls)
static

MQ finished giving our last message to CADET, now notify the client that we are finished.

Definition at line 388 of file gnunet-service-scalarproduct_bob.c.

389{
390 struct BobServiceSession *session = cls;
391
394}
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.

References GNUNET_SCALARPRODUCT_STATUS_SUCCESS, prepare_client_end_notification(), and BobServiceSession::status.

Referenced by transmit_bobs_cryptodata_message(), and transmit_bobs_cryptodata_message_multipart().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_bobs_cryptodata_message_multipart()

static void transmit_bobs_cryptodata_message_multipart ( struct BobServiceSession s)
static

Send a multipart chunk of a service response from Bob to Alice.

This element only contains the two permutations of R, R'.

Parameters
sthe associated service session

Definition at line 413 of file gnunet-service-scalarproduct_bob.c.

414{
417 struct GNUNET_MQ_Envelope *e;
418 unsigned int i;
419 unsigned int j;
420 uint32_t todo_count;
421
423 {
425 if (todo_count > ELEMENT_CAPACITY / 2)
426 todo_count = ELEMENT_CAPACITY / 2;
427
429 "Sending %u additional crypto values to Alice\n",
430 (unsigned int) todo_count);
432 todo_count * sizeof(struct
434 * 2,
436 msg->contained_element_count = htonl (todo_count);
438 for (i = s->cadet_transmitted_element_count, j = 0; i <
439 s->cadet_transmitted_element_count + todo_count; i++)
440 {
441 // r[i][p] and r[i][q]
442 GNUNET_memcpy (&payload[j++],
443 &s->r[i],
444 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
445 GNUNET_memcpy (&payload[j++],
446 &s->r_prime[i],
447 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
448 }
449 s->cadet_transmitted_element_count += todo_count;
453 s);
455 e);
456 }
458 "All values queued for Alice, Bob is done\n");
459}
static unsigned long long payload
How much data are we currently storing in the database?
#define ELEMENT_CAPACITY
Maximum count of elements we can put into a multipart message.
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART
Bob -> Alice SP crypto-data multipart.
uint32_t cadet_transmitted_element_count
Counts the number of values transmitted from us to Alice.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, ELEMENT_CAPACITY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), msg, payload, BobServiceSession::r, BobServiceSession::r_prime, and BobServiceSession::used_element_count.

Referenced by transmit_bobs_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_bobs_cryptodata_message()

static void transmit_bobs_cryptodata_message ( struct BobServiceSession s)
static

Bob generates the response message to be sent to Alice after computing the values (1), (2), S and S'.

(1)[]: $E_A(a_{pi(i)}) times E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) times E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$

Parameters
sthe associated requesting session with Alice

Definition at line 474 of file gnunet-service-scalarproduct_bob.c.

475{
477 struct GNUNET_MQ_Envelope *e;
479 unsigned int i;
480
482 = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct
484 / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
487
490 * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
492 msg->contained_element_count = htonl (s->cadet_transmitted_element_count);
493
495 "Sending %u/%u crypto values to Alice\n",
496 (unsigned int) s->cadet_transmitted_element_count,
497 (unsigned int) s->used_element_count);
498
501 &s->s,
502 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
504 &s->s_prime,
505 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
506
507 payload = &payload[2];
508 // convert k[][]
509 for (i = 0; i < s->cadet_transmitted_element_count; i++)
510 {
511 // k[i][p] and k[i][q]
512 GNUNET_memcpy (&payload[i * 2],
513 &s->r[i],
514 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
515 GNUNET_memcpy (&payload[i * 2 + 1],
516 &s->r_prime[i],
517 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
518 }
522 s);
524 e);
526}
static void transmit_bobs_cryptodata_message_multipart(struct BobServiceSession *s)
Send a multipart chunk of a service response from Bob to Alice.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA
Bob -> Alice SP crypto-data.
Message type passed from responding service Bob to responding service Alice to complete a request and...
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob's "s'".

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), msg, payload, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::s, BobServiceSession::s_prime, transmit_bobs_cryptodata_message_multipart(), and BobServiceSession::used_element_count.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ compute_square_sum()

static gcry_mpi_t compute_square_sum ( const gcry_mpi_t *  vector,
uint32_t  length 
)
static

Computes the square sum over a vector of a given length.

Parameters
vectorthe vector to compute over
lengththe length of the vector
Returns
an MPI value containing the calculated sum, never NULL TODO: code duplication with Alice!

Definition at line 541 of file gnunet-service-scalarproduct_bob.c.

543{
544 gcry_mpi_t elem;
545 gcry_mpi_t sum;
546 uint32_t i;
547
548 GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
549 GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
550 for (i = 0; i < length; i++)
551 {
552 gcry_mpi_mul (elem, vector[i], vector[i]);
553 gcry_mpi_add (sum, sum, elem);
554 }
555 gcry_mpi_release (elem);
556 return sum;
557}
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References GNUNET_assert, and consensus-simulation::sum.

Referenced by compute_service_response().

Here is the caller graph for this function:

◆ compute_service_response()

static int compute_service_response ( struct BobServiceSession session)
static

Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) otimes E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$.

Parameters
sessionthe requesting session + bob's requesting peer
Returns
GNUNET_OK on success

Definition at line 571 of file gnunet-service-scalarproduct_bob.c.

572{
573 uint32_t i;
574 unsigned int *p;
575 unsigned int *q;
576 uint32_t count;
577 gcry_mpi_t *rand;
578 gcry_mpi_t tmp;
579 const struct MpiElement *b;
582 struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
583
584 count = session->used_element_count;
585 a = session->e_a;
586 b = session->sorted_elements;
588 count);
590 count);
591 rand = GNUNET_malloc (sizeof(gcry_mpi_t) * count);
592 for (i = 0; i < count; i++)
593 GNUNET_assert (NULL != (rand[i] = gcry_mpi_new (0)));
594 r = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
595 r_prime = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
596 * count);
597
598 for (i = 0; i < count; i++)
599 {
600 int32_t svalue;
601
603 UINT32_MAX);
604 // long to gcry_mpi_t
605 if (svalue < 0)
606 gcry_mpi_sub_ui (rand[i],
607 rand[i],
608 -svalue);
609 else
610 rand[i] = gcry_mpi_set_ui (rand[i], svalue);
611 }
612
613 tmp = gcry_mpi_new (0);
614 // encrypt the element
615 // for the sake of readability I decided to have dedicated permutation
616 // vectors, which get rid of all the lookups in p/q.
617 // however, ap/aq are not absolutely necessary but are just abstraction
618 // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
619 for (i = 0; i < count; i++)
620 {
621 // E(S - r_pi - b_pi)
622 gcry_mpi_sub (tmp, my_offset, rand[p[i]]);
623 gcry_mpi_sub (tmp, tmp, b[p[i]].value);
624 GNUNET_assert (2 ==
626 tmp,
627 2,
628 &r[i]));
629
630 // E(S - r_pi - b_pi) * E(S + a_pi) == E(2*S + a - r - b)
631 if (GNUNET_OK !=
633 &r[i],
634 &a[p[i]],
635 &r[i]))
636 {
637 GNUNET_break_op (0);
638 goto error_cleanup;
639 }
640 }
641
642 // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
643 for (i = 0; i < count; i++)
644 {
645 // E(S - r_qi)
646 gcry_mpi_sub (tmp, my_offset, rand[q[i]]);
647 GNUNET_assert (2 ==
649 tmp,
650 2,
651 &r_prime[i]));
652
653 // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
654 if (GNUNET_OK !=
656 &r_prime[i],
657 &a[q[i]],
658 &r_prime[i]))
659 {
660 GNUNET_break_op (0);
661 goto error_cleanup;
662 }
663 }
664 gcry_mpi_release (tmp);
665
666 // Calculate S' = E(SUM( r_i^2 ))
667 tmp = compute_square_sum (rand, count);
668 GNUNET_assert (1 ==
670 tmp,
671 1,
672 &session->s_prime));
673 gcry_mpi_release (tmp);
674
675 // Calculate S = E(SUM( (r_i + b_i)^2 ))
676 for (i = 0; i < count; i++)
677 gcry_mpi_add (rand[i], rand[i], b[i].value);
678 tmp = compute_square_sum (rand, count);
679 GNUNET_assert (1 ==
681 tmp,
682 1,
683 &session->s));
684 gcry_mpi_release (tmp);
685
686 session->r = r;
687 session->r_prime = r_prime;
688
689 for (i = 0; i < count; i++)
690 gcry_mpi_release (rand[i]);
691 GNUNET_free (session->e_a);
692 session->e_a = NULL;
693 GNUNET_free (p);
694 GNUNET_free (q);
695 GNUNET_free (rand);
696 return GNUNET_OK;
697
698error_cleanup:
699 GNUNET_free (r);
700 GNUNET_free (r_prime);
701 gcry_mpi_release (tmp);
702 GNUNET_free (p);
703 GNUNET_free (q);
704 for (i = 0; i < count; i++)
705 gcry_mpi_release (rand[i]);
706 GNUNET_free (rand);
707 return GNUNET_SYSERR;
708}
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
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 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
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
unsigned int * GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
Get an array with a random permutation of the numbers 0...n-1.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
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.
int GNUNET_CRYPTO_paillier_hom_add(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *c1, const struct GNUNET_CRYPTO_PaillierCiphertext *c2, struct GNUNET_CRYPTO_PaillierCiphertext *result)
Compute a ciphertext that represents the sum of the plaintext in c1 and c2.
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_CRYPTO_PaillierPublicKey remote_pubkey
Public key of the remote service.
An encrypted element key-value pair.

References compute_square_sum(), BobServiceSession::e_a, GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_paillier_encrypt(), GNUNET_CRYPTO_paillier_hom_add(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_permute(), GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, my_offset, p, q, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::remote_pubkey, BobServiceSession::s, BobServiceSession::s_prime, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, and value.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ copy_element_cb()

static int copy_element_cb ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Iterator to copy over messages from the hash map into an array for sorting.

Parameters
clsthe struct BobServiceSession *
keythe key (unused)
valuethe struct GNUNET_SCALARPRODUCT_Element * TODO: code duplication with Alice!

Definition at line 721 of file gnunet-service-scalarproduct_bob.c.

724{
725 struct BobServiceSession *s = cls;
727 gcry_mpi_t mval;
728 int64_t val;
729
730 mval = gcry_mpi_new (0);
731 val = (int64_t) GNUNET_ntohll (e->value);
732 if (0 > val)
733 gcry_mpi_sub_ui (mval, mval, -val);
734 else
735 gcry_mpi_add_ui (mval, mval, val);
739 return GNUNET_OK;
740}
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
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.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.

References GNUNET_ntohll(), GNUNET_OK, MpiElement::key, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::s, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, value, MpiElement::value, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ element_cmp()

static int element_cmp ( const void *  a,
const void *  b 
)
static

Compare two struct MpiValues by key for sorting.

Parameters
apointer to first struct MpiValue *
bpointer to first struct MpiValue *
Returns
-1 for a < b, 0 for a=b, 1 for a > b. TODO: code duplication with Alice!

Definition at line 752 of file gnunet-service-scalarproduct_bob.c.

754{
755 const struct MpiElement *ma = a;
756 const struct MpiElement *mb = b;
757
758 return GNUNET_CRYPTO_hash_cmp (ma->key,
759 mb->key);
760}
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

References GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_cryptographic_reply()

static void transmit_cryptographic_reply ( struct BobServiceSession s)
static

Intersection operation and receiving data via CADET from Alice are both done, compute and transmit our reply via CADET.

Parameters
ssession to transmit reply for.

Definition at line 771 of file gnunet-service-scalarproduct_bob.c.

772{
773 struct GNUNET_CADET_Channel *channel;
774
775 /* TODO: code duplication with Alice! */
777 "Received everything, building reply for Alice\n");
781 * sizeof(struct MpiElement));
782 s->used_element_count = 0;
785 s);
786 qsort (s->sorted_elements,
788 sizeof(struct MpiElement),
789 &element_cmp);
790 if (GNUNET_OK !=
792 {
793 channel = s->channel;
794 s->channel = NULL;
796 return;
797 }
799}
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice after computing the values (1),...
static int compute_service_response(struct BobServiceSession *session)
Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{p...
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
#define LOG(kind,...)
static int copy_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to copy over messages from the hash map into an array for sorting.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
Opaque handle to a channel.
Definition: cadet.h:116

References BobServiceSession::channel, compute_service_response(), copy_element_cb(), element_cmp(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_malloc, GNUNET_OK, BobServiceSession::intersected_elements, LOG, BobServiceSession::sorted_elements, transmit_bobs_cryptodata_message(), and BobServiceSession::used_element_count.

Referenced by cb_intersection_element_removed(), and handle_alices_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_alices_cryptodata_message()

static int check_alices_cryptodata_message ( void *  cls,
const struct AliceCryptodataMessage msg 
)
static

Check a multipart-chunk of a request from another service to calculate a scalarproduct with us.

Parameters
clsthe struct BobServiceSession *
msgthe actual message
Returns
GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 812 of file gnunet-service-scalarproduct_bob.c.

814{
815 struct BobServiceSession *s = cls;
816 uint32_t contained_elements;
817 size_t msg_length;
818 uint16_t msize;
819 unsigned int max;
820
821 msize = ntohs (msg->header.size);
822 contained_elements = ntohl (msg->contained_element_count);
823 /* Our intersection may still be ongoing, but this is nevertheless
824 an upper bound on the required array size */
825 max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
826 msg_length = sizeof(struct AliceCryptodataMessage)
827 + contained_elements * sizeof(struct
829 if ((msize != msg_length) ||
830 (0 == contained_elements) ||
831 (contained_elements > UINT16_MAX) ||
832 (max < contained_elements + s->cadet_received_element_count))
833 {
834 GNUNET_break_op (0);
835 return GNUNET_SYSERR;
836 }
837 return GNUNET_OK;
838}
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#define max(x, y)
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection).
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.

References BobServiceSession::cadet_received_element_count, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SYSERR, max, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_alices_cryptodata_message()

static void handle_alices_cryptodata_message ( void *  cls,
const struct AliceCryptodataMessage msg 
)
static

Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us.

Parameters
clsthe struct BobServiceSession *
msgthe actual message

Definition at line 849 of file gnunet-service-scalarproduct_bob.c.

851{
852 struct BobServiceSession *s = cls;
854 uint32_t contained_elements;
855 unsigned int max;
856
857 contained_elements = ntohl (msg->contained_element_count);
858 /* Our intersection may still be ongoing, but this is nevertheless
859 an upper bound on the required array size */
862 "Received %u crypto values from Alice\n",
863 (unsigned int) contained_elements);
864
865 payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
866 if (NULL == s->e_a)
870 payload,
872 * contained_elements);
873 s->cadet_received_element_count += contained_elements;
874
875 if ((s->cadet_received_element_count == max) &&
876 (NULL == s->intersection_op))
877 {
878 /* intersection has finished also on our side, and
879 we got the full set, so we can proceed with the
880 CADET response(s) */
882 }
884}
static void transmit_cryptographic_reply(struct BobServiceSession *s)
Intersection operation and receiving data via CADET from Alice are both done, compute and transmit ou...
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
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, BobServiceSession::e_a, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_new_array, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, max, msg, payload, BobServiceSession::s, and transmit_cryptographic_reply().

Here is the call graph for this function:

◆ cb_intersection_element_removed()

static void cb_intersection_element_removed ( void *  cls,
const struct GNUNET_SETI_Element element,
uint64_t  current_size,
enum GNUNET_SETI_Status  status 
)
static

Callback for set operation results.

Called for each element that needs to be removed from the result set.

Parameters
clsclosure with the struct BobServiceSession
elementa result element, only valid if status is #GNUNET_SETI_STATUS_OK
current_sizecurrent set size
statuswhat has happened with the set intersection?

Definition at line 897 of file gnunet-service-scalarproduct_bob.c.

901{
902 struct BobServiceSession *s = cls;
904
905 switch (status)
906 {
908 /* this element has been removed from the set */
910 element->data);
911 GNUNET_assert (NULL != se);
913 "Removed element with key %s and value %lld\n",
914 GNUNET_h2s (&se->key),
915 (long long) GNUNET_ntohll (se->value));
919 element->data,
920 se));
921 GNUNET_free (se);
922 return;
924 s->intersection_op = NULL;
925 GNUNET_break (NULL == s->intersection_set);
928 "Finished intersection, %d items remain\n",
932 {
933 /* CADET transmission from Alice is also already done,
934 start with our own reply */
936 }
937 return;
939 /* unhandled status code */
941 "Set intersection failed!\n");
942 s->intersection_op = NULL;
943 if (NULL != s->intersection_set)
944 {
946 s->intersection_set = NULL;
947 }
950 return;
951 default:
952 GNUNET_break (0);
953 return;
954 }
955}
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ 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.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
const void * data
Actual data of the element.

References BobServiceSession::channel, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_destroy(), GNUNET_SETI_STATUS_DEL_LOCAL, GNUNET_SETI_STATUS_DONE, GNUNET_SETI_STATUS_FAILURE, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), BobServiceSession::s, status, BobServiceSession::status, transmit_cryptographic_reply(), and GNUNET_SCALARPRODUCT_Element::value.

Here is the call graph for this function:

◆ start_intersection()

static void start_intersection ( struct BobServiceSession s)
static

We've paired up a client session with an incoming CADET request.

Initiate set intersection work.

Parameters
sclient session to start intersection for

Definition at line 965 of file gnunet-service-scalarproduct_bob.c.

966{
968 "Got session with key %s and %u elements, starting intersection.\n",
970 (unsigned int) s->total);
971
974 &s->session_id,
975 NULL,
976 (struct GNUNET_SETI_Option[]) { { 0 } },
978 s);
979 if (GNUNET_OK !=
982 {
983 GNUNET_break (0);
986 return;
987 }
989 s->intersection_set = NULL;
990}
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.
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_OperationHandle * GNUNET_SETI_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: seti_api.c:513
uint32_t total
How many elements will be supplied in total from the client.
struct GNUNET_PeerIdentity peer
Originator's peer identity.
Option for set operations.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SETI_prepare(), BobServiceSession::intersection_op, BobServiceSession::peer, BobServiceSession::session_id, and BobServiceSession::total.

Referenced by handle_alices_computation_request(), and handle_bob_client_message_multipart().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_alices_computation_request()

static void handle_alices_computation_request ( void *  cls,
const struct ServiceRequestMessage msg 
)
static

Handle a request from Alice to calculate a scalarproduct with us (Bob).

Parameters
clsthe struct BobServiceSession *
msgthe actual message

Definition at line 1000 of file gnunet-service-scalarproduct_bob.c.

1002{
1003 struct BobServiceSession *s = cls;
1004
1005 s->session_id = msg->session_id; // ??
1006 s->remote_pubkey = msg->public_key;
1007 if (s->client_received_element_count == s->total)
1009}
static void start_intersection(struct BobServiceSession *s)
We've paired up a client session with an incoming CADET request.

References msg, BobServiceSession::s, and start_intersection().

Here is the call graph for this function:

◆ cb_channel_incoming()

static void * cb_channel_incoming ( void *  cls,
struct GNUNET_CADET_Channel channel,
const struct GNUNET_PeerIdentity initiator 
)
static

Function called for inbound channels on Bob's end.

Does some preliminary initialization, more happens after we get Alice's first message.

Parameters
clsclosure with the struct BobServiceSession
channelnew handle to the channel
initiatorpeer that started the channel
Returns
session associated with the channel

Definition at line 1023 of file gnunet-service-scalarproduct_bob.c.

1026{
1027 struct BobServiceSession *s = cls;
1028
1030 "New incoming channel from peer %s.\n",
1031 GNUNET_i2s (initiator));
1032 GNUNET_CADET_close_port (s->port);
1033 s->port = NULL;
1034 s->channel = channel;
1035 s->peer = *initiator;
1036 s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
1037 return s;
1038}
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

References BobServiceSession::channel, GNUNET_CADET_close_port(), GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, and BobServiceSession::s.

Referenced by handle_bob_client_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_bob_client_message_multipart()

static int check_bob_client_message_multipart ( void *  cls,
const struct ComputationBobCryptodataMultipartMessage msg 
)
static

We're receiving additional set data.

Check it is well-formed.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

Definition at line 1049 of file gnunet-service-scalarproduct_bob.c.

1053{
1054 struct BobServiceSession *s = cls;
1055 uint32_t contained_count;
1056 uint16_t msize;
1057
1058 msize = ntohs (msg->header.size);
1059 contained_count = ntohl (msg->element_count_contained);
1060 if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
1061 + contained_count * sizeof(struct
1063 (0 == contained_count) ||
1064 (UINT16_MAX < contained_count) ||
1065 (s->total == s->client_received_element_count) ||
1066 (s->total < s->client_received_element_count + contained_count))
1067 {
1068 GNUNET_break (0);
1069 return GNUNET_SYSERR;
1070 }
1071 return GNUNET_OK;
1072}
multipart messages following struct ComputationMessage

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

◆ handle_bob_client_message_multipart()

static void handle_bob_client_message_multipart ( void *  cls,
const struct ComputationBobCryptodataMultipartMessage msg 
)
static

We're receiving additional set data.

Add it to our set and if we are done, initiate the transaction.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 1083 of file gnunet-service-scalarproduct_bob.c.

1087{
1088 struct BobServiceSession *s = cls;
1089 uint32_t contained_count;
1090 const struct GNUNET_SCALARPRODUCT_Element *elements;
1091 struct GNUNET_SETI_Element set_elem;
1092 struct GNUNET_SCALARPRODUCT_Element *elem;
1093
1094 contained_count = ntohl (msg->element_count_contained);
1095 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1096 for (uint32_t i = 0; i < contained_count; i++)
1097 {
1099 GNUNET_memcpy (elem,
1100 &elements[i],
1101 sizeof(struct GNUNET_SCALARPRODUCT_Element));
1102 if (GNUNET_SYSERR ==
1104 &elem->key,
1105 elem,
1107 {
1108 GNUNET_break (0);
1109 GNUNET_free (elem);
1110 continue;
1111 }
1112 set_elem.data = &elem->key;
1113 set_elem.size = sizeof(elem->key);
1114 set_elem.element_type = 0;
1116 &set_elem,
1117 NULL, NULL);
1118 }
1119 s->client_received_element_count += contained_count;
1122 {
1123 /* more to come */
1124 return;
1125 }
1126 if (NULL == s->channel)
1127 {
1128 /* no Alice waiting for this request, wait for Alice */
1129 return;
1130 }
1132}
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.
@ 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_new(type)
Allocate a struct or union of the given type.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
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
Element stored in a set.

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SETI_add_element(), GNUNET_SYSERR, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, BobServiceSession::s, GNUNET_SETI_Element::size, start_intersection(), and BobServiceSession::total.

Here is the call graph for this function:

◆ check_bob_client_message()

static int check_bob_client_message ( void *  cls,
const struct BobComputationMessage msg 
)
static

Handler for Bob's a client request message.

Check msg is well-formed.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

Definition at line 1144 of file gnunet-service-scalarproduct_bob.c.

1146{
1147 struct BobServiceSession *s = cls;
1148 uint32_t contained_count;
1149 uint32_t total_count;
1150 uint16_t msize;
1151
1152 if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
1153 {
1154 GNUNET_break (0);
1155 return GNUNET_SYSERR;
1156 }
1157 msize = ntohs (msg->header.size);
1158 total_count = ntohl (msg->element_count_total);
1159 contained_count = ntohl (msg->element_count_contained);
1160 if ((0 == total_count) ||
1161 (0 == contained_count) ||
1162 (UINT16_MAX < contained_count) ||
1163 (msize != (sizeof(struct BobComputationMessage)
1164 + contained_count * sizeof(struct
1166 {
1167 GNUNET_break_op (0);
1168 return GNUNET_SYSERR;
1169 }
1170 return GNUNET_OK;
1171}
@ GNUNET_SCALARPRODUCT_STATUS_INIT
Operation is still active (never returned, used internally).
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:89

References GNUNET_break, GNUNET_break_op, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_INIT, GNUNET_SYSERR, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

◆ handle_bob_client_message()

static void handle_bob_client_message ( void *  cls,
const struct BobComputationMessage msg 
)
static

Handler for Bob's a client request message.

Bob is in the response role, keep the values + session and waiting for a matching session or process a waiting request from Alice.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 1183 of file gnunet-service-scalarproduct_bob.c.

1185{
1186 struct BobServiceSession *s = cls;
1187 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
1188 GNUNET_MQ_hd_fixed_size (alices_computation_request,
1190 struct ServiceRequestMessage,
1191 NULL),
1192 GNUNET_MQ_hd_var_size (alices_cryptodata_message,
1195 NULL),
1197 };
1198 uint32_t contained_count;
1199 uint32_t total_count;
1200 const struct GNUNET_SCALARPRODUCT_Element *elements;
1201 struct GNUNET_SETI_Element set_elem;
1202 struct GNUNET_SCALARPRODUCT_Element *elem;
1203
1204 total_count = ntohl (msg->element_count_total);
1205 contained_count = ntohl (msg->element_count_contained);
1206
1208 s->total = total_count;
1209 s->client_received_element_count = contained_count;
1210 s->session_id = msg->session_key;
1211 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1214 GNUNET_YES);
1216 for (uint32_t i = 0; i < contained_count; i++)
1217 {
1218 if (0 == GNUNET_ntohll (elements[i].value))
1219 continue;
1221 GNUNET_memcpy (elem,
1222 &elements[i],
1223 sizeof(struct GNUNET_SCALARPRODUCT_Element));
1224 if (GNUNET_SYSERR ==
1226 &elem->key,
1227 elem,
1229 {
1230 GNUNET_break (0);
1231 GNUNET_free (elem);
1232 continue;
1233 }
1234 set_elem.data = &elem->key;
1235 set_elem.size = sizeof(elem->key);
1236 set_elem.element_type = 0;
1238 &set_elem,
1239 NULL, NULL);
1240 s->used_element_count++;
1241 }
1243 /* We're ready, open the port */
1245 &msg->session_key,
1247 s,
1248 NULL,
1250 cadet_handlers);
1251 if (NULL == s->port)
1252 {
1253 GNUNET_break (0);
1255 return;
1256 }
1257}
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob's end.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
Alice -> Bob SP crypto-data (after intersection)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
Alice -> Bob session initialization.
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
Message handler for a specific message type.
Message type passed from requesting service Alice to responding service Bob to initiate a request and...

References cb_channel_destruction(), cb_channel_incoming(), cfg, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CADET_open_port(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SETI_add_element(), GNUNET_SETI_create(), GNUNET_SYSERR, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, my_cadet, BobServiceSession::port, BobServiceSession::s, BobServiceSession::session_id, GNUNET_SETI_Element::size, BobServiceSession::status, BobServiceSession::total, BobServiceSession::used_element_count, and value.

Here is the call graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 1266 of file gnunet-service-scalarproduct_bob.c.

1267{
1269 "Shutting down, initiating cleanup.\n");
1270 // FIXME: we have to cut our connections to CADET first!
1271 if (NULL != my_cadet)
1272 {
1274 my_cadet = NULL;
1275 }
1276}
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774

References GNUNET_CADET_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and my_cadet.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void * client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

A client connected.

Setup the associated data structure.

Parameters
clsclosure, NULL
clientidentification of the client
mqmessage queue to communicate with client
Returns
our struct BobServiceSession

Definition at line 1290 of file gnunet-service-scalarproduct_bob.c.

1293{
1294 struct BobServiceSession *s;
1295
1296 s = GNUNET_new (struct BobServiceSession);
1297 s->client = client;
1298 s->client_mq = mq;
1299 return s;
1300}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5

References BobServiceSession::client, GNUNET_new, mq, and BobServiceSession::s.

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_cls 
)
static

A client disconnected.

Remove the associated session(s), release data structures and cancel pending outgoing transmissions to the client.

Parameters
clsclosure, NULL
clientidentification of the client
app_clsour struct BobServiceSession

Definition at line 1314 of file gnunet-service-scalarproduct_bob.c.

1317{
1318 struct BobServiceSession *s = app_cls;
1319
1321 "Client disconnected from us.\n");
1322 s->client = NULL;
1324}

References destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and BobServiceSession::s.

Here is the call graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Initialization of the program and message handlers.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

Definition at line 1335 of file gnunet-service-scalarproduct_bob.c.

1338{
1339 cfg = c;
1340 /*
1341 offset has to be sufficiently small to allow computation of:
1342 m1+m2 mod n == (S + a) + (S + b) mod n,
1343 if we have more complex operations, this factor needs to be lowered */
1344 my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
1345 gcry_mpi_set_bit (my_offset,
1347
1349 &my_privkey);
1352 NULL);
1353 if (NULL == my_cadet)
1354 {
1356 _ ("Connect to CADET failed\n"));
1358 return;
1359 }
1360}
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
Service's own private key.
static void shutdown_task(void *cls)
Task run during shutdown.
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
Service's own public key.
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
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
void GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
Create a freshly generated paillier public key.
@ GNUNET_ERROR_TYPE_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
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

References _, cfg, GNUNET_CADET_connect(), GNUNET_CRYPTO_PAILLIER_BITS, GNUNET_CRYPTO_paillier_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), my_cadet, my_offset, my_privkey, my_pubkey, and shutdown_task().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

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.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

GNUnet configuration handle.

Definition at line 209 of file gnunet-service-scalarproduct_bob.c.

Referenced by handle_bob_client_message(), and run().

◆ my_pubkey

struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
static

Service's own public key.

Definition at line 214 of file gnunet-service-scalarproduct_bob.c.

Referenced by run().

◆ my_privkey

struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
static

Service's own private key.

Definition at line 219 of file gnunet-service-scalarproduct_bob.c.

Referenced by run().

◆ my_offset

gcry_mpi_t my_offset
static

Service's offset for values that could possibly be negative but are plaintext for encryption.

Definition at line 224 of file gnunet-service-scalarproduct_bob.c.

Referenced by compute_service_response(), and run().

◆ my_cadet

struct GNUNET_CADET_Handle* my_cadet
static

Handle to the CADET service.

Definition at line 229 of file gnunet-service-scalarproduct_bob.c.

Referenced by handle_bob_client_message(), run(), and shutdown_task().