GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
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_set_service.h"
#include "scalarproduct.h"
#include "gnunet-service-scalarproduct.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   ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct BobCryptodataMultipartMessage)) / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext))
 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_SET_Element *element, uint64_t current_size, enum GNUNET_SET_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__)

◆ ELEMENT_CAPACITY

#define ELEMENT_CAPACITY   ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct BobCryptodataMultipartMessage)) / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext))

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

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

Referenced by transmit_bobs_cryptodata_message_multipart().

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 238 of file gnunet-service-scalarproduct_bob.c.

References GNUNET_free, GNUNET_OK, and MpiElement::value.

Referenced by destroy_service_session().

241 {
242  struct GNUNET_SCALARPRODUCT_Element *element = value;
243 
244  GNUNET_free(element);
245  return GNUNET_OK;
246 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * value
Value of the record to add/remove.
An element key-value pair for scalarproduct.
#define GNUNET_free(ptr)
Wrapper around free.
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 255 of file gnunet-service-scalarproduct_bob.c.

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_SET_destroy(), GNUNET_SET_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().

256 {
257  unsigned int i;
258 
259  if (GNUNET_YES == s->in_destroy)
260  return;
261  s->in_destroy = GNUNET_YES;
262  if (NULL != s->client)
263  {
264  struct GNUNET_SERVICE_Client *c = s->client;
265 
266  s->client = NULL;
268  }
269  if (NULL != s->intersected_elements)
270  {
273  NULL);
275  s->intersected_elements = NULL;
276  }
277  if (NULL != s->intersection_op)
278  {
280  s->intersection_op = NULL;
281  }
282  if (NULL != s->intersection_set)
283  {
285  s->intersection_set = NULL;
286  }
287  if (NULL != s->e_a)
288  {
289  GNUNET_free(s->e_a);
290  s->e_a = NULL;
291  }
292  if (NULL != s->sorted_elements)
293  {
294  for (i = 0; i < s->used_element_count; i++)
295  gcry_mpi_release(s->sorted_elements[i].value);
297  s->sorted_elements = NULL;
298  }
299  if (NULL != s->r)
300  {
301  GNUNET_free(s->r);
302  s->r = NULL;
303  }
304  if (NULL != s->r_prime)
305  {
306  GNUNET_free(s->r_prime);
307  s->r_prime = NULL;
308  }
309  if (NULL != s->port)
310  {
312  s->port = NULL;
313  }
314  if (NULL != s->channel)
315  {
317  s->channel = NULL;
318  }
319  GNUNET_free(s);
320 }
int in_destroy
Are we already in destroy_service_session()?
struct GNUNET_CRYPTO_PaillierCiphertext * e_a
E(ai)(Bob) after applying the mask.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct MpiElement * sorted_elements
b(Bob)
gcry_mpi_t value
a_i value, not disclosed to Bob.
Handle to a client that is connected to a service.
Definition: service.c:246
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:767
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_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2315
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob&#39;s permutation p of R.
void GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh)
Cancel the given set operation.
Definition: set_api.c:511
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:871
#define GNUNET_YES
Definition: gnunet_common.h:77
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:900
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob&#39;s permutation q of R.
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 331 of file gnunet-service-scalarproduct_bob.c.

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

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

332 {
333  struct ClientResponseMessage *msg;
334  struct GNUNET_MQ_Envelope *e;
335 
336  if (NULL == session->client_mq)
337  return; /* no client left to be notified */
339  "Sending session-end notification with status %d to client for session %s\n",
340  session->status,
341  GNUNET_h2s(&session->session_id));
342  e = GNUNET_MQ_msg(msg,
344  msg->range = 0;
345  msg->product_length = htonl(0);
346  msg->status = htonl(session->status);
347  GNUNET_MQ_send(session->client_mq,
348  e);
349 }
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
uint32_t product_length
0 if no product attached
#define GNUNET_log(kind,...)
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:351
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
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 362 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by handle_bob_client_message().

364 {
365  struct BobServiceSession *s = cls;
366 
368  "Peer disconnected, terminating session %s with peer %s\n",
369  GNUNET_h2s(&s->session_id),
370  GNUNET_i2s(&s->peer));
372  {
375  }
376  s->channel = NULL;
378 }
Operation is still active (never returned, used internally).
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_log(kind,...)
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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 386 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by transmit_bobs_cryptodata_message(), and transmit_bobs_cryptodata_message_multipart().

387 {
388  struct BobServiceSession *session = cls;
389 
392 }
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
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 408 of file gnunet-service-scalarproduct_bob.c.

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, BobCryptodataMultipartMessage::contained_element_count, e, 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().

409 {
412  struct GNUNET_MQ_Envelope *e;
413  unsigned int i;
414  unsigned int j;
415  uint32_t todo_count;
416 
418  {
420  if (todo_count > ELEMENT_CAPACITY / 2)
421  todo_count = ELEMENT_CAPACITY / 2;
422 
424  "Sending %u additional crypto values to Alice\n",
425  (unsigned int)todo_count);
426  e = GNUNET_MQ_msg_extra(msg,
427  todo_count * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * 2,
429  msg->contained_element_count = htonl(todo_count);
430  payload = (struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1];
431  for (i = s->cadet_transmitted_element_count, j = 0; i < s->cadet_transmitted_element_count + todo_count; i++)
432  {
433  //r[i][p] and r[i][q]
434  GNUNET_memcpy(&payload[j++],
435  &s->r[i],
436  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
437  GNUNET_memcpy(&payload[j++],
438  &s->r_prime[i],
439  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
440  }
441  s->cadet_transmitted_element_count += todo_count;
445  s);
447  e);
448  }
450  "All values queued for Alice, Bob is done\n");
451 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t used_element_count
How many elements actually are used for the scalar product.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static struct Experiment * e
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_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:52
uint32_t cadet_transmitted_element_count
Counts the number of values transmitted from us to Alice.
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:772
Multipart Message type passed between to supply additional elements for the peer. ...
#define ELEMENT_CAPACITY
Maximum count of elements we can put into a multipart message.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART
Bob -> Alice SP crypto-data multipart.
static unsigned long long payload
How much data are we currently storing in the database?
uint32_t contained_element_count
How many elements we supply within this message? In NBO.
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob&#39;s permutation p of R.
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:351
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob&#39;s permutation q of R.
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 466 of file gnunet-service-scalarproduct_bob.c.

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, BobCryptodataMessage::contained_element_count, e, 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().

467 {
468  struct BobCryptodataMessage *msg;
469  struct GNUNET_MQ_Envelope *e;
471  unsigned int i;
472 
475  / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
478 
479  e = GNUNET_MQ_msg_extra(msg,
481  * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
484 
486  "Sending %u/%u crypto values to Alice\n",
487  (unsigned int)s->cadet_transmitted_element_count,
488  (unsigned int)s->used_element_count);
489 
490  payload = (struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1];
491  GNUNET_memcpy(&payload[0],
492  &s->s,
493  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
494  GNUNET_memcpy(&payload[1],
495  &s->s_prime,
496  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
497 
498  payload = &payload[2];
499  // convert k[][]
500  for (i = 0; i < s->cadet_transmitted_element_count; i++)
501  {
502  //k[i][p] and k[i][q]
503  GNUNET_memcpy(&payload[i * 2],
504  &s->r[i],
505  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
506  GNUNET_memcpy(&payload[i * 2 + 1],
507  &s->r_prime[i],
508  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
509  }
513  s);
515  e);
517 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t used_element_count
How many elements actually are used for the scalar product.
Message type passed from responding service Bob to responding service Alice to complete a request and...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static struct Experiment * e
static void transmit_bobs_cryptodata_message_multipart(struct BobServiceSession *s)
Send a multipart chunk of a service response from Bob to Alice.
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_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:52
uint32_t cadet_transmitted_element_count
Counts the number of values transmitted from us to Alice.
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob&#39;s "s&#39;".
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:772
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA
Bob -> Alice SP crypto-data.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
static unsigned long long payload
How much data are we currently storing in the database?
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob&#39;s permutation p of R.
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:351
uint32_t contained_element_count
How many elements this individual message delivers (in NBO).
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob&#39;s permutation q of R.
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 530 of file gnunet-service-scalarproduct_bob.c.

References GNUNET_assert.

Referenced by compute_service_response().

532 {
533  gcry_mpi_t elem;
534  gcry_mpi_t sum;
535  uint32_t i;
536 
537  GNUNET_assert(NULL != (sum = gcry_mpi_new(0)));
538  GNUNET_assert(NULL != (elem = gcry_mpi_new(0)));
539  for (i = 0; i < length; i++)
540  {
541  gcry_mpi_mul(elem, vector[i], vector[i]);
542  gcry_mpi_add(sum, sum, elem);
543  }
544  gcry_mpi_release(elem);
545  return sum;
546 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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
requestthe requesting session + bob's requesting peer
Returns
GNUNET_OK on success

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

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 MpiElement::value.

Referenced by transmit_cryptographic_reply().

561 {
562  uint32_t i;
563  unsigned int *p;
564  unsigned int *q;
565  uint32_t count;
566  gcry_mpi_t *rand;
567  gcry_mpi_t tmp;
568  const struct MpiElement *b;
571  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
572 
573  count = session->used_element_count;
574  a = session->e_a;
575  b = session->sorted_elements;
577  count);
579  count);
580  rand = GNUNET_malloc(sizeof(gcry_mpi_t) * count);
581  for (i = 0; i < count; i++)
582  GNUNET_assert(NULL != (rand[i] = gcry_mpi_new(0)));
583  r = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
584  r_prime = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
585 
586  for (i = 0; i < count; i++)
587  {
588  int32_t svalue;
589 
591  UINT32_MAX);
592  // long to gcry_mpi_t
593  if (svalue < 0)
594  gcry_mpi_sub_ui(rand[i],
595  rand[i],
596  -svalue);
597  else
598  rand[i] = gcry_mpi_set_ui(rand[i], svalue);
599  }
600 
601  tmp = gcry_mpi_new(0);
602  // encrypt the element
603  // for the sake of readability I decided to have dedicated permutation
604  // vectors, which get rid of all the lookups in p/q.
605  // however, ap/aq are not absolutely necessary but are just abstraction
606  // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
607  for (i = 0; i < count; i++)
608  {
609  // E(S - r_pi - b_pi)
610  gcry_mpi_sub(tmp, my_offset, rand[p[i]]);
611  gcry_mpi_sub(tmp, tmp, b[p[i]].value);
612  GNUNET_assert(2 ==
614  tmp,
615  2,
616  &r[i]));
617 
618  // E(S - r_pi - b_pi) * E(S + a_pi) == E(2*S + a - r - b)
619  if (GNUNET_OK !=
621  &r[i],
622  &a[p[i]],
623  &r[i]))
624  {
625  GNUNET_break_op(0);
626  goto error_cleanup;
627  }
628  }
629 
630  // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
631  for (i = 0; i < count; i++)
632  {
633  // E(S - r_qi)
634  gcry_mpi_sub(tmp, my_offset, rand[q[i]]);
635  GNUNET_assert(2 ==
637  tmp,
638  2,
639  &r_prime[i]));
640 
641  // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
642  if (GNUNET_OK !=
644  &r_prime[i],
645  &a[q[i]],
646  &r_prime[i]))
647  {
648  GNUNET_break_op(0);
649  goto error_cleanup;
650  }
651  }
652  gcry_mpi_release(tmp);
653 
654  // Calculate S' = E(SUM( r_i^2 ))
655  tmp = compute_square_sum(rand, count);
656  GNUNET_assert(1 ==
658  tmp,
659  1,
660  &session->s_prime));
661  gcry_mpi_release(tmp);
662 
663  // Calculate S = E(SUM( (r_i + b_i)^2 ))
664  for (i = 0; i < count; i++)
665  gcry_mpi_add(rand[i], rand[i], b[i].value);
666  tmp = compute_square_sum(rand, count);
667  GNUNET_assert(1 ==
669  tmp,
670  1,
671  &session->s));
672  gcry_mpi_release(tmp);
673 
674  session->r = r;
675  session->r_prime = r_prime;
676 
677  for (i = 0; i < count; i++)
678  gcry_mpi_release(rand[i]);
679  GNUNET_free(session->e_a);
680  session->e_a = NULL;
681  GNUNET_free(p);
682  GNUNET_free(q);
683  GNUNET_free(rand);
684  return GNUNET_OK;
685 
686 error_cleanup:
687  GNUNET_free(r);
688  GNUNET_free(r_prime);
689  gcry_mpi_release(tmp);
690  GNUNET_free(p);
691  GNUNET_free(q);
692  for (i = 0; i < count; i++)
693  gcry_mpi_release(rand[i]);
694  GNUNET_free(rand);
695  return GNUNET_SYSERR;
696 }
struct GNUNET_CRYPTO_PaillierPublicKey remote_pubkey
Public key of the remote service.
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.
struct GNUNET_CRYPTO_PaillierCiphertext * e_a
E(ai)(Bob) after applying the mask.
uint32_t used_element_count
How many elements actually are used for the scalar product.
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.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct MpiElement * sorted_elements
b(Bob)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob&#39;s "s&#39;".
static char * value
Value of the record to add/remove.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static gcry_mpi_t my_offset
Service&#39;s offset for values that could possibly be negative but are plaintext for encryption...
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
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 x1 and x2.
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
An encrypted element key-value pair.
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob&#39;s permutation p of R.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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.
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob&#39;s permutation q of R.
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 709 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by transmit_cryptographic_reply().

712 {
713  struct BobServiceSession *s = cls;
715  gcry_mpi_t mval;
716  int64_t val;
717 
718  mval = gcry_mpi_new(0);
719  val = (int64_t)GNUNET_ntohll(e->value);
720  if (0 > val)
721  gcry_mpi_sub_ui(mval, mval, -val);
722  else
723  gcry_mpi_add_ui(mval, mval, val);
726  s->used_element_count++;
727  return GNUNET_OK;
728 }
uint32_t used_element_count
How many elements actually are used for the scalar product.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
static struct Experiment * e
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct MpiElement * sorted_elements
b(Bob)
gcry_mpi_t value
a_i value, not disclosed to Bob.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
static char * value
Value of the record to add/remove.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
int64_t value
Value to multiply in scalar product, in NBO.
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
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 740 of file gnunet-service-scalarproduct_bob.c.

References GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by transmit_cryptographic_reply().

742 {
743  const struct MpiElement *ma = a;
744  const struct MpiElement *mb = b;
745 
746  return GNUNET_CRYPTO_hash_cmp(ma->key,
747  mb->key);
748 }
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
An encrypted element key-value pair.
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:278
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 759 of file gnunet-service-scalarproduct_bob.c.

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().

760 {
761  struct GNUNET_CADET_Channel *channel;
762 
763  /* TODO: code duplication with Alice! */
765  "Received everything, building reply for Alice\n");
766  s->sorted_elements
768  sizeof(struct MpiElement));
769  s->used_element_count = 0;
772  s);
773  qsort(s->sorted_elements,
775  sizeof(struct MpiElement),
776  &element_cmp);
777  if (GNUNET_OK !=
779  {
780  channel = s->channel;
781  s->channel = NULL;
783  return;
784  }
786 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
uint32_t used_element_count
How many elements actually are used for the scalar product.
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.
#define LOG(kind,...)
Opaque handle to a channel.
Definition: cadet_api.c:79
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct MpiElement * sorted_elements
b(Bob)
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_{pi(i)...
struct GNUNET_CADET_Channel * channel
The CADET channel.
An encrypted element key-value pair.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:900
#define GNUNET_malloc(size)
Wrapper around malloc.
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 799 of file gnunet-service-scalarproduct_bob.c.

References AliceCryptodataMessage::contained_element_count, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SYSERR, AliceCryptodataMessage::header, BobServiceSession::intersected_elements, BobServiceSession::s, and GNUNET_MessageHeader::size.

801 {
802  struct BobServiceSession *s = cls;
803  uint32_t contained_elements;
804  size_t msg_length;
805  uint16_t msize;
806  unsigned int max;
807 
808  msize = ntohs(msg->header.size);
809  contained_elements = ntohl(msg->contained_element_count);
810  /* Our intersection may still be ongoing, but this is nevertheless
811  an upper bound on the required array size */
813  msg_length = sizeof(struct AliceCryptodataMessage)
814  + contained_elements * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
815  if ((msize != msg_length) ||
816  (0 == contained_elements) ||
817  (contained_elements > UINT16_MAX) ||
818  (max < contained_elements + s->cadet_received_element_count))
819  {
820  GNUNET_break_op(0);
821  return GNUNET_SYSERR;
822  }
823  return GNUNET_OK;
824 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection). ...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
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 835 of file gnunet-service-scalarproduct_bob.c.

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, AliceCryptodataMessage::contained_element_count, 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, payload, BobServiceSession::s, and transmit_cryptographic_reply().

837 {
838  struct BobServiceSession *s = cls;
840  uint32_t contained_elements;
841  unsigned int max;
842 
843  contained_elements = ntohl(msg->contained_element_count);
844  /* Our intersection may still be ongoing, but this is nevertheless
845  an upper bound on the required array size */
848  "Received %u crypto values from Alice\n",
849  (unsigned int)contained_elements);
850 
851  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1];
852  if (NULL == s->e_a)
853  s->e_a = GNUNET_new_array(max,
856  payload,
857  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * contained_elements);
858  s->cadet_received_element_count += contained_elements;
859 
860  if ((s->cadet_received_element_count == max) &&
861  (NULL == s->intersection_op))
862  {
863  /* intersection has finished also on our side, and
864  we got the full set, so we can proceed with the
865  CADET response(s) */
867  }
869 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_CRYPTO_PaillierCiphertext * e_a
E(ai)(Bob) after applying the mask.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_CADET_Channel * channel
The CADET channel.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void transmit_cryptographic_reply(struct BobServiceSession *s)
Intersection operation and receiving data via CADET from Alice are both done, compute and transmit ou...
static unsigned long long payload
How much data are we currently storing in the database?
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:951
#define GNUNET_log(kind,...)
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
Here is the call graph for this function:

◆ cb_intersection_element_removed()

static void cb_intersection_element_removed ( void *  cls,
const struct GNUNET_SET_Element element,
uint64_t  current_size,
enum GNUNET_SET_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_SET_STATUS_OK
current_sizecurrent set size
statuswhat has happened with the set intersection?

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

References BobServiceSession::channel, BobServiceSession::client_received_element_count, GNUNET_SET_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_SET_destroy(), GNUNET_SET_STATUS_DONE, GNUNET_SET_STATUS_FAILURE, GNUNET_SET_STATUS_HALF_DONE, GNUNET_SET_STATUS_OK, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), BobServiceSession::s, BobServiceSession::status, transmit_cryptographic_reply(), and GNUNET_SCALARPRODUCT_Element::value.

886 {
887  struct BobServiceSession *s = cls;
888  struct GNUNET_SCALARPRODUCT_Element *se;
889 
890  switch (status)
891  {
893  /* this element has been removed from the set */
895  element->data);
896  GNUNET_assert(NULL != se);
898  "Removed element with key %s and value %lld\n",
899  GNUNET_h2s(&se->key),
900  (long long)GNUNET_ntohll(se->value));
903  element->data,
904  se));
905  GNUNET_free(se);
906  return;
907 
909  s->intersection_op = NULL;
910  GNUNET_break(NULL == s->intersection_set);
913  "Finished intersection, %d items remain\n",
917  {
918  /* CADET transmission from Alice is also already done,
919  start with our own reply */
921  }
922  return;
923 
925  /* unexpected for intersection */
926  GNUNET_break(0);
927  return;
928 
930  /* unhandled status code */
932  "Set intersection failed!\n");
933  s->intersection_op = NULL;
934  if (NULL != s->intersection_set)
935  {
937  s->intersection_set = NULL;
938  }
941  return;
942 
943  default:
944  GNUNET_break(0);
945  return;
946  }
947 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
#define LOG(kind,...)
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
A scalarproduct session which tracks an offer for a multiplication service by a local client...
Success, all elements have been sent (and received).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const void * data
Actual data of the element.
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.
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:767
The other peer refused to to the operation with us, or something went wrong.
Success, all elements have been returned (but the other peer might still be receiving some from us...
Everything went ok, we are transmitting an element of the result (in set, or to be removed from set...
struct GNUNET_CADET_Channel * channel
The CADET channel.
uint16_t status
See PRISM_STATUS_*-constants.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void transmit_cryptographic_reply(struct BobServiceSession *s)
Intersection operation and receiving data via CADET from Alice are both done, compute and transmit ou...
int64_t value
Value to multiply in scalar product, in NBO.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:951
#define GNUNET_YES
Definition: gnunet_common.h:77
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
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 957 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by handle_alices_computation_request(), and handle_bob_client_message_multipart().

958 {
960  "Got session with key %s and %u elements, starting intersection.\n",
961  GNUNET_h2s(&s->session_id),
962  (unsigned int)s->total);
963 
964  s->intersection_op
965  = GNUNET_SET_prepare(&s->peer,
966  &s->session_id,
967  NULL,
969  (struct GNUNET_SET_Option[]) { { 0 } },
971  s);
972  if (GNUNET_OK !=
974  s->intersection_set))
975  {
976  GNUNET_break(0);
979  return;
980  }
982  s->intersection_set = NULL;
983 }
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_SET_OperationHandle * GNUNET_SET_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: set_api.c:808
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:767
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SET_Element *element, uint64_t current_size, enum GNUNET_SET_Status status)
Callback for set operation results.
uint32_t total
How many elements will be supplied in total from the client.
Option for set operations.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
int GNUNET_SET_commit(struct GNUNET_SET_OperationHandle *oh, struct GNUNET_SET_Handle *set)
Commit a set to be used with a set operation.
Definition: set_api.c:1123
#define GNUNET_log(kind,...)
Client gets only elements that have been removed from the set.
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
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 993 of file gnunet-service-scalarproduct_bob.c.

References BobServiceSession::client_received_element_count, ServiceRequestMessage::public_key, BobServiceSession::remote_pubkey, BobServiceSession::s, ServiceRequestMessage::session_id, BobServiceSession::session_id, start_intersection(), and BobServiceSession::total.

995 {
996  struct BobServiceSession *s = cls;
997 
998  s->session_id = msg->session_id; // ??
999  s->remote_pubkey = msg->public_key;
1000  if (s->client_received_element_count == s->total)
1001  start_intersection(s);
1002 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
struct GNUNET_CRYPTO_PaillierPublicKey public_key
Alice&#39;s public key.
struct GNUNET_CRYPTO_PaillierPublicKey remote_pubkey
Public key of the remote service.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
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 1016 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by handle_bob_client_message().

1019 {
1020  struct BobServiceSession *s = cls;
1021 
1023  "New incoming channel from peer %s.\n",
1024  GNUNET_i2s(initiator));
1026  s->port = NULL;
1027  s->channel = channel;
1028  s->peer = *initiator;
1030  return s;
1031 }
struct GNUNET_CADET_Port * port
Our open port.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_log(kind,...)
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:871
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1116
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 1042 of file gnunet-service-scalarproduct_bob.c.

References BobServiceSession::client_received_element_count, ComputationBobCryptodataMultipartMessage::element_count_contained, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, ComputationBobCryptodataMultipartMessage::header, BobServiceSession::s, GNUNET_MessageHeader::size, and BobServiceSession::total.

1044 {
1045  struct BobServiceSession *s = cls;
1046  uint32_t contained_count;
1047  uint16_t msize;
1048 
1049  msize = ntohs(msg->header.size);
1050  contained_count = ntohl(msg->element_count_contained);
1051  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage) +
1052  contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
1053  (0 == contained_count) ||
1054  (UINT16_MAX < contained_count) ||
1055  (s->total == s->client_received_element_count) ||
1056  (s->total < s->client_received_element_count + contained_count))
1057  {
1058  GNUNET_break(0);
1059  return GNUNET_SYSERR;
1060  }
1061  return GNUNET_OK;
1062 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_MessageHeader header
GNUNET message header.
uint32_t element_count_contained
contained elements the vector in payload contains
multipart messages following struct ComputationMessage
An element key-value pair for scalarproduct.

◆ 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 1073 of file gnunet-service-scalarproduct_bob.c.

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SET_Element::data, ComputationBobCryptodataMultipartMessage::element_count_contained, GNUNET_SET_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_SET_add_element(), GNUNET_SYSERR, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::s, GNUNET_SET_Element::size, start_intersection(), and BobServiceSession::total.

1075 {
1076  struct BobServiceSession *s = cls;
1077  uint32_t contained_count;
1078  const struct GNUNET_SCALARPRODUCT_Element *elements;
1079  struct GNUNET_SET_Element set_elem;
1080  struct GNUNET_SCALARPRODUCT_Element *elem;
1081 
1082  contained_count = ntohl(msg->element_count_contained);
1083  elements = (const struct GNUNET_SCALARPRODUCT_Element *)&msg[1];
1084  for (uint32_t i = 0; i < contained_count; i++)
1085  {
1087  GNUNET_memcpy(elem,
1088  &elements[i],
1089  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1090  if (GNUNET_SYSERR ==
1092  &elem->key,
1093  elem,
1095  {
1096  GNUNET_break(0);
1097  GNUNET_free(elem);
1098  continue;
1099  }
1100  set_elem.data = &elem->key;
1101  set_elem.size = sizeof(elem->key);
1102  set_elem.element_type = 0;
1104  &set_elem,
1105  NULL, NULL);
1106  }
1107  s->client_received_element_count += contained_count;
1109  if (s->total != s->client_received_element_count)
1110  {
1111  /* more to come */
1112  return;
1113  }
1114  if (NULL == s->channel)
1115  {
1116  /* no Alice waiting for this request, wait for Alice */
1117  return;
1118  }
1119  start_intersection(s);
1120 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
int GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
Add an element to the given set.
Definition: set_api.c:682
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
Element stored in a set.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
uint32_t element_count_contained
contained elements the vector in payload contains
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2234
An element key-value pair for scalarproduct.
#define GNUNET_free(ptr)
Wrapper around free.
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 1132 of file gnunet-service-scalarproduct_bob.c.

References BobComputationMessage::element_count_contained, BobComputationMessage::element_count_total, GNUNET_break, GNUNET_break_op, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_INIT, GNUNET_SYSERR, BobComputationMessage::header, BobServiceSession::s, GNUNET_MessageHeader::size, and BobServiceSession::status.

1134 {
1135  struct BobServiceSession *s = cls;
1136  uint32_t contained_count;
1137  uint32_t total_count;
1138  uint16_t msize;
1139 
1141  {
1142  GNUNET_break(0);
1143  return GNUNET_SYSERR;
1144  }
1145  msize = ntohs(msg->header.size);
1146  total_count = ntohl(msg->element_count_total);
1147  contained_count = ntohl(msg->element_count_contained);
1148  if ((0 == total_count) ||
1149  (0 == contained_count) ||
1150  (UINT16_MAX < contained_count) ||
1151  (msize != (sizeof(struct BobComputationMessage) +
1152  contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
1153  {
1154  GNUNET_break_op(0);
1155  return GNUNET_SYSERR;
1156  }
1157  return GNUNET_OK;
1158 }
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:94
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB.
Definition: scalarproduct.h:89
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Operation is still active (never returned, used internally).
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t element_count_contained
contained elements the vector in payload contains
Definition: scalarproduct.h:99
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:84
An element key-value pair for scalarproduct.

◆ 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 1170 of file gnunet-service-scalarproduct_bob.c.

References cb_channel_destruction(), cb_channel_incoming(), BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SET_Element::data, BobComputationMessage::element_count_contained, BobComputationMessage::element_count_total, GNUNET_SET_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_SET_add_element(), GNUNET_SET_create(), GNUNET_SET_OPERATION_INTERSECTION, GNUNET_SYSERR, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::port, BobServiceSession::s, BobServiceSession::session_id, BobComputationMessage::session_key, GNUNET_SET_Element::size, BobServiceSession::status, BobServiceSession::total, BobServiceSession::used_element_count, and MpiElement::value.

1172 {
1173  struct BobServiceSession *s = cls;
1174  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
1175  GNUNET_MQ_hd_fixed_size(alices_computation_request,
1177  struct ServiceRequestMessage,
1178  NULL),
1179  GNUNET_MQ_hd_var_size(alices_cryptodata_message,
1181  struct AliceCryptodataMessage,
1182  NULL),
1184  };
1185  uint32_t contained_count;
1186  uint32_t total_count;
1187  const struct GNUNET_SCALARPRODUCT_Element *elements;
1188  struct GNUNET_SET_Element set_elem;
1189  struct GNUNET_SCALARPRODUCT_Element *elem;
1190 
1191  total_count = ntohl(msg->element_count_total);
1192  contained_count = ntohl(msg->element_count_contained);
1193 
1195  s->total = total_count;
1196  s->client_received_element_count = contained_count;
1197  s->session_id = msg->session_key;
1198  elements = (const struct GNUNET_SCALARPRODUCT_Element *)&msg[1];
1201  GNUNET_YES);
1202  s->intersection_set
1205  for (uint32_t i = 0; i < contained_count; i++)
1206  {
1207  if (0 == GNUNET_ntohll(elements[i].value))
1208  continue;
1210  GNUNET_memcpy(elem,
1211  &elements[i],
1212  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1213  if (GNUNET_SYSERR ==
1215  &elem->key,
1216  elem,
1218  {
1219  GNUNET_break(0);
1220  GNUNET_free(elem);
1221  continue;
1222  }
1223  set_elem.data = &elem->key;
1224  set_elem.size = sizeof(elem->key);
1225  set_elem.element_type = 0;
1227  &set_elem,
1228  NULL, NULL);
1229  s->used_element_count++;
1230  }
1232  /* We're ready, open the port */
1234  &msg->session_key,
1236  s,
1237  NULL,
1239  cadet_handlers);
1240  if (NULL == s->port)
1241  {
1242  GNUNET_break(0);
1244  return;
1245  }
1246 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
int GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
Add an element to the given set.
Definition: set_api.c:682
uint32_t used_element_count
How many elements actually are used for the scalar product.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
Alice -> Bob session initialization.
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:94
Operation is still active (never returned, used internally).
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Element stored in a set.
struct GNUNET_SET_Handle * GNUNET_SET_create(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op)
Create an empty set, supporting the specified operation.
Definition: set_api.c:652
struct GNUNET_CADET_Port * port
Our open port.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
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 incomming MQ-based channels.
Definition: cadet_api.c:1007
static char * value
Value of the record to add/remove.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob&#39;s end.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2315
Message handler for a specific message type.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection). ...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
uint32_t element_count_contained
contained elements the vector in payload contains
Definition: scalarproduct.h:99
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
Alice -> Bob SP crypto-data (after intersection)
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
Set intersection, only return elements that are in both sets.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2234
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
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 1255 of file gnunet-service-scalarproduct_bob.c.

References GNUNET_CADET_disconnect(), GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by run().

1256 {
1258  "Shutting down, initiating cleanup.\n");
1259  // FIXME: we have to cut our connections to CADET first!
1260  if (NULL != my_cadet)
1261  {
1263  my_cadet = NULL;
1264  }
1265 }
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:838
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
#define GNUNET_log(kind,...)
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 1279 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by run().

1282 {
1283  struct BobServiceSession *s;
1284 
1285  s = GNUNET_new(struct BobServiceSession);
1286  s->client = client;
1287  s->client_mq = mq;
1288  return s;
1289 }
struct GNUNET_MQ_Handle * client_mq
Client message queue.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Here is the caller graph for this function:

◆ 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 1303 of file gnunet-service-scalarproduct_bob.c.

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

Referenced by run().

1306 {
1307  struct BobServiceSession *s = app_cls;
1308 
1310  "Client disconnected from us.\n");
1311  s->client = NULL;
1313 }
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller 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 1324 of file gnunet-service-scalarproduct_bob.c.

References _, client_connect_cb(), client_disconnect_cb(), GNUNET_CADET_connect(), GNUNET_CRYPTO_PAILLIER_BITS, GNUNET_CRYPTO_paillier_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, my_offset, my_privkey, my_pubkey, and shutdown_task().

1327 {
1328  cfg = c;
1329  /*
1330  offset has to be sufficiently small to allow computation of:
1331  m1+m2 mod n == (S + a) + (S + b) mod n,
1332  if we have more complex operations, this factor needs to be lowered */
1333  my_offset = gcry_mpi_new(GNUNET_CRYPTO_PAILLIER_BITS / 3);
1334  gcry_mpi_set_bit(my_offset,
1336 
1338  &my_privkey);
1341  NULL);
1342  if (NULL == my_cadet)
1343  {
1345  _("Connect to CADET failed\n"));
1347  return;
1348  }
1349 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1284
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
Service&#39;s own private key.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:973
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 _(String)
GNU gettext support macro.
Definition: platform.h:181
static gcry_mpi_t my_offset
Service&#39;s offset for values that could possibly be negative but are plaintext for encryption...
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
Service&#39;s own public key.
static void shutdown_task(void *cls)
Task run during shutdown.
#define GNUNET_log(kind,...)
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
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.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

GNUnet configuration handle.

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

◆ my_pubkey

struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
static

Service's own public key.

Definition at line 212 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 217 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 222 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 227 of file gnunet-service-scalarproduct_bob.c.