GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-service-scalarproduct-ecc_alice.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-ecc.h"
Include dependency graph for gnunet-service-scalarproduct-ecc_alice.c:

Go to the source code of this file.

Data Structures

struct  MpiElement
 An encrypted element key-value pair. More...
 
struct  AliceServiceSession
 A scalarproduct session which tracks a request form the client to our final response. More...
 

Macros

#define LOG(kind, ...)    GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
 
#define MAX_RESULT   (1024 * 1024)
 Maximum allowed result value for the scalarproduct computation. More...
 
#define MAX_RAM   (1024)
 How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes times the value given here). More...
 
#define ELEMENT_CAPACITY
 Maximum number of elements we can put into a single cryptodata message. More...
 

Functions

static int free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator called to free elements. More...
 
static void destroy_service_session (struct AliceServiceSession *s)
 Destroy session state, we are done with it. More...
 
static void prepare_client_end_notification (struct AliceServiceSession *session)
 Notify the client that the session has failed. More...
 
static void transmit_client_response (struct AliceServiceSession *s)
 Prepare the final (positive) response we will send to Alice's client. More...
 
static void cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
static void handle_bobs_cryptodata_message (void *cls, const struct EccBobCryptodataMessage *msg)
 Handle a response we got from another service we wanted to calculate a scalarproduct with. 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 send_alices_cryptodata_message (struct AliceServiceSession *s)
 Send the cryptographic data from Alice to Bob. 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 cb_intersection_request_alice (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
 Called when another peer wants to do a set operation with the local peer. More...
 
static void client_request_complete_alice (struct AliceServiceSession *s)
 Our client has finished sending us its multipart message. More...
 
static int check_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static void handle_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static int check_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
 Handler for Alice's client request message. More...
 
static void handle_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
 Handler for Alice's 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-alice", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL), GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 GNUnet configuration handle. More...
 
static struct GNUNET_CRYPTO_EccDlogContextedc
 Context for DLOG operations on a curve. More...
 
static struct GNUNET_CRYPTO_EccScalar my_privkey
 Alice's private key ('a'). More...
 
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv
 Inverse of Alice's private key ('a_inv'). 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-ecc_alice.c.

Macro Definition Documentation

◆ LOG

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

Definition at line 39 of file gnunet-service-scalarproduct-ecc_alice.c.

◆ MAX_RESULT

#define MAX_RESULT   (1024 * 1024)

Maximum allowed result value for the scalarproduct computation.

DLOG will fail if the result is bigger. At 1 million, the precomputation takes about 2s on a fast machine.

Definition at line 47 of file gnunet-service-scalarproduct-ecc_alice.c.

◆ MAX_RAM

#define MAX_RAM   (1024)

How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes times the value given here).

Should be about SQRT (MAX_RESULT), larger values will make the online computation faster.

Definition at line 55 of file gnunet-service-scalarproduct-ecc_alice.c.

◆ ELEMENT_CAPACITY

#define ELEMENT_CAPACITY
Value:
- sizeof(struct EccAliceCryptodataMessage)) \
/ sizeof(struct GNUNET_CRYPTO_EccPoint))
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...

Maximum number of elements we can put into a single cryptodata message.

Definition at line 528 of file gnunet-service-scalarproduct-ecc_alice.c.

Function Documentation

◆ free_element_cb()

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

Iterator called to free elements.

Parameters
clsthe struct AliceServiceSession * (unused)
keythe key (unused)
valuevalue to free
Returns
GNUNET_OK (continue to iterate)

Definition at line 215 of file gnunet-service-scalarproduct-ecc_alice.c.

218 {
220 
221  GNUNET_free (e);
222  return GNUNET_OK;
223 }
static struct Experiment * e
static char * value
Value of the record to add/remove.
@ GNUNET_OK
Definition: gnunet_common.h:95
#define GNUNET_free(ptr)
Wrapper around free.
An element key-value pair for scalarproduct.

References e, 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 AliceServiceSession s)
static

Destroy session state, we are done with it.

Parameters
sthe session to free elements from

Definition at line 232 of file gnunet-service-scalarproduct-ecc_alice.c.

233 {
234  if (GNUNET_YES == s->in_destroy)
235  return;
236  s->in_destroy = GNUNET_YES;
237  if (NULL != s->client)
238  {
239  struct GNUNET_SERVICE_Client *c = s->client;
240 
241  s->client = NULL;
243  }
244  if (NULL != s->channel)
245  {
247  s->channel = NULL;
248  }
249  if (NULL != s->intersected_elements)
250  {
253  s);
255  s->intersected_elements = NULL;
256  }
257  if (NULL != s->intersection_listen)
258  {
260  s->intersection_listen = NULL;
261  }
262  if (NULL != s->intersection_op)
263  {
265  "Set intersection, op still ongoing!\n");
267  s->intersection_op = NULL;
268  }
269  if (NULL != s->intersection_set)
270  {
272  s->intersection_set = NULL;
273  }
274  if (NULL != s->sorted_elements)
275  {
277  s->sorted_elements = NULL;
278  }
279  GNUNET_free (s);
280 }
#define LOG(kind,...)
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called to free elements.
@ GNUNET_YES
Definition: gnunet_common.h:97
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
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_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
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
void GNUNET_SETI_listen_cancel(struct GNUNET_SETI_ListenHandle *lh)
Cancel the given listen operation.
Definition: seti_api.c:747
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value'd elements transmitted to us.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which will conduction an intersection.
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
struct GNUNET_SETI_ListenHandle * intersection_listen
Handle to Alice's Intersection operation listening for Bob.
Handle to a client that is connected to a service.
Definition: service.c:251

References AliceServiceSession::channel, AliceServiceSession::client, free_element_cb(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_SETI_destroy(), GNUNET_SETI_listen_cancel(), GNUNET_SETI_operation_cancel(), GNUNET_YES, AliceServiceSession::in_destroy, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_listen, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, LOG, and AliceServiceSession::sorted_elements.

Referenced by client_disconnect_cb(), and handle_bobs_cryptodata_message().

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 AliceServiceSession session)
static

Notify the client that the session has failed.

A message gets sent to Alice's client if we encountered any error.

Parameters
sessionthe associated client session to fail or succeed

Definition at line 290 of file gnunet-service-scalarproduct-ecc_alice.c.

291 {
292  struct ClientResponseMessage *msg;
293  struct GNUNET_MQ_Envelope *e;
294 
295  if (NULL == session->client_mq)
296  return; /* no client left to be notified */
297  GNUNET_log (
299  "Sending session-end notification with status %d to client for session %s\n",
300  session->status,
301  GNUNET_h2s (&session->session_id));
302  e = GNUNET_MQ_msg (msg,
304  msg->product_length = htonl (0);
305  msg->status = htonl (session->status);
306  GNUNET_MQ_send (session->client_mq,
307  e);
308 }
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).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Message type passed from service client to finalize a session as requester or responder.

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

Referenced by cb_channel_destruction(), cb_intersection_element_removed(), cb_intersection_request_alice(), client_request_complete_alice(), and transmit_client_response().

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

◆ transmit_client_response()

static void transmit_client_response ( struct AliceServiceSession s)
static

Prepare the final (positive) response we will send to Alice's client.

Parameters
sthe session associated with our client.

Definition at line 318 of file gnunet-service-scalarproduct-ecc_alice.c.

319 {
320  struct ClientResponseMessage *msg;
321  struct GNUNET_MQ_Envelope *e;
322  unsigned char *product_exported = NULL;
323  size_t product_length = 0;
324  int32_t range;
325  gcry_error_t rc;
326  gcry_mpi_t value;
327 
328  if (INT_MAX == s->product)
329  {
330  GNUNET_break (0);
332  return;
333  }
334  value = gcry_mpi_new (32);
335  if (0 > s->product)
336  {
337  range = -1;
338  gcry_mpi_set_ui (value,
339  -s->product);
340  }
341  else if (0 < s->product)
342  {
343  range = 1;
344  gcry_mpi_set_ui (value,
345  s->product);
346  }
347  else
348  {
349  /* result is exactly zero */
350  range = 0;
351  }
352  if ( (0 != range) &&
353  (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
354  &product_exported,
355  &product_length,
356  value))))
357  {
359  "gcry_mpi_scan",
360  rc);
362  return;
363  }
364  gcry_mpi_release (value);
366  product_length,
368  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
369  msg->range = htonl (range);
370  msg->product_length = htonl (product_length);
371  if (NULL != product_exported)
372  {
373  GNUNET_memcpy (&msg[1],
374  product_exported,
375  product_length);
376  GNUNET_free (product_exported);
377  }
379  e);
381  "Sent result to client, session %s has ended!\n",
382  GNUNET_h2s (&s->session_id));
383 }
#define INT_MAX
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#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
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.
#define LOG_GCRY(level, cmd, rc)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition: scalarproduct.h:35
int product
The computed scalar product.

References AliceServiceSession::client_mq, e, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SCALARPRODUCT_STATUS_SUCCESS, INT_MAX, LOG_GCRY, msg, prepare_client_end_notification(), AliceServiceSession::product, AliceServiceSession::session_id, and value.

Referenced by handle_bobs_cryptodata_message().

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 AliceServiceSession
channelconnection to the other end (henceforth invalid)

Definition at line 396 of file gnunet-service-scalarproduct-ecc_alice.c.

398 {
399  struct AliceServiceSession *s = cls;
400 
402  "Peer disconnected, terminating session %s with peer %s\n",
403  GNUNET_h2s (&s->session_id),
404  GNUNET_i2s (&s->peer));
405  s->channel = NULL;
406  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
407  {
408  /* We didn't get an answer yet, fail with error */
411  }
412 }
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 a request form the client to our final response.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".

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

Referenced by client_request_complete_alice().

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

◆ handle_bobs_cryptodata_message()

static void handle_bobs_cryptodata_message ( void *  cls,
const struct EccBobCryptodataMessage msg 
)
static

Handle a response we got from another service we wanted to calculate a scalarproduct with.

Parameters
clsthe struct AliceServiceSession *
msgthe actual message

Definition at line 423 of file gnunet-service-scalarproduct-ecc_alice.c.

425 {
426  struct AliceServiceSession *s = cls;
427  uint32_t contained;
428 
429  contained = ntohl (msg->contained_element_count);
430  if (2 != contained)
431  {
432  GNUNET_break_op (0);
434  return;
435  }
436  if (NULL == s->sorted_elements)
437  {
438  /* we're not ready yet, how can Bob be? */
439  GNUNET_break_op (0);
441  return;
442  }
443  if (s->total != s->client_received_element_count)
444  {
445  /* we're not ready yet, how can Bob be? */
446  GNUNET_break_op (0);
448  return;
449  }
451  "Received %u crypto values from Bob\n",
452  (unsigned int) contained);
453  GNUNET_CADET_receive_done (s->channel);
454  {
455  struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
456  struct GNUNET_CRYPTO_EccPoint g_ai_bi;
457 
458  GNUNET_assert (
459  GNUNET_OK ==
460  GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
462  &g_i_b_i_a_inv));
463  GNUNET_assert (
464  GNUNET_OK ==
465  GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
466  &msg->prod_h_i_b_i,
467  &g_ai_bi));
469  &g_ai_bi);
470  if (INT_MAX == s->product)
471  {
472  /* result too big */
474  "Scalar product result out of range\n");
475  }
476  }
478 }
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv
Inverse of Alice's private key ('a_inv').
static void transmit_client_response(struct AliceServiceSession *s)
Prepare the final (positive) response we will send to Alice's client.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi(const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the point p on the elliptic curve by val.
int GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *input)
Calculate ECC discrete logarithm for small factors.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add(const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
Add two points on the elliptic curve.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References destroy_service_session(), edc, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_dlog(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, INT_MAX, msg, my_privkey_inv, AliceServiceSession::product, AliceServiceSession::s, and transmit_client_response().

Here is the call 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 AliceServiceSession *
keythe key (unused)
valuethe struct GNUNET_SCALARPRODUCT_Element *

Definition at line 490 of file gnunet-service-scalarproduct-ecc_alice.c.

493 {
494  struct AliceServiceSession *s = cls;
496 
498  e->value);
499  s->sorted_elements[s->used_element_count].key = &e->key;
500  s->used_element_count++;
501  return GNUNET_OK;
502 }
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
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.
int64_t value
a_i value, not disclosed to Bob.

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

Referenced by send_alices_cryptodata_message().

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.

Definition at line 513 of file gnunet-service-scalarproduct-ecc_alice.c.

515 {
516  const struct MpiElement *ma = a;
517  const struct MpiElement *mb = b;
518 
519  return GNUNET_CRYPTO_hash_cmp (ma->key,
520  mb->key);
521 }
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:201
An encrypted element key-value pair.

References testconfigure::b, GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by send_alices_cryptodata_message().

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

◆ send_alices_cryptodata_message()

static void send_alices_cryptodata_message ( struct AliceServiceSession s)
static

Send the cryptographic data from Alice to Bob.

Does nothing if we already transferred all elements.

Parameters
sthe associated service session

Definition at line 541 of file gnunet-service-scalarproduct-ecc_alice.c.

542 {
544  struct GNUNET_MQ_Envelope *e;
546  struct GNUNET_CRYPTO_EccScalar r_ia;
547  struct GNUNET_CRYPTO_EccScalar r_ia_ai;
548  unsigned int off;
549  unsigned int todo_count;
550 
553  struct MpiElement);
554  s->used_element_count = 0;
557  s);
559  "Finished intersection, %d items remain\n",
560  s->used_element_count);
561  qsort (s->sorted_elements,
563  sizeof(struct MpiElement),
564  &element_cmp);
565  off = 0;
566  while (off < s->used_element_count)
567  {
568  todo_count = s->used_element_count - off;
569  if (todo_count > ELEMENT_CAPACITY)
570  todo_count = ELEMENT_CAPACITY;
572  "Sending %u/%u crypto values to Bob\n",
573  (unsigned int) todo_count,
574  (unsigned int) s->used_element_count);
575 
576  e =
578  todo_count * 2
579  * sizeof(struct GNUNET_CRYPTO_EccPoint),
581  msg->contained_element_count = htonl (todo_count);
582  payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
583  for (unsigned int i = off; i < off + todo_count; i++)
584  {
585  struct GNUNET_CRYPTO_EccScalar r_i;
586  struct GNUNET_CRYPTO_EccPoint g_i;
587  struct GNUNET_CRYPTO_EccPoint h_i;
588 
589  /* r_i = random() mod n */
591  /* g_i = g^{r_i} */
594  &g_i));
595  /* r_ia = r_i * a */
596  crypto_core_ed25519_scalar_mul (r_ia.v,
597  r_i.v,
598  my_privkey.v);
599  /* r_ia_ai = r_ia + a_i */
600  {
601  int64_t val = s->sorted_elements[i].value;
602  struct GNUNET_CRYPTO_EccScalar vali;
603 
604  GNUNET_assert (INT64_MIN != val);
605  GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
606  &vali);
607  if (val > 0)
608  crypto_core_ed25519_scalar_add (r_ia_ai.v,
609  r_ia.v,
610  vali.v);
611  else
612  crypto_core_ed25519_scalar_sub (r_ia_ai.v,
613  r_ia.v,
614  vali.v);
615  }
616  /* h_i = g^{r_ia_ai} */
618  GNUNET_CRYPTO_ecc_dexp_mpi (&r_ia_ai,
619  &h_i));
620  memcpy (&payload[(i - off) * 2],
621  &g_i,
622  sizeof (g_i));
623  memcpy (&payload[(i - off) * 2 + 1],
624  &h_i,
625  sizeof (h_i));
626  }
627  off += todo_count;
629  e);
630  }
631 }
static unsigned long long payload
How much data are we currently storing in the database?
static struct GNUNET_CRYPTO_EccScalar my_privkey
Alice's private key ('a').
#define ELEMENT_CAPACITY
Maximum number of elements we can put into a single cryptodata message.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
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.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_dexp_mpi(const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
void GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccScalar *r)
Generate a random value mod n.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
A ECC scalar for use in point multiplications.
unsigned char v[256/8]

References AliceServiceSession::cadet_mq, copy_element_cb(), e, ELEMENT_CAPACITY, element_cmp(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecc_dexp_mpi(), GNUNET_CRYPTO_ecc_random_mod_n(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new_array, GNUNET_OK, AliceServiceSession::intersected_elements, LOG, msg, my_privkey, payload, AliceServiceSession::sorted_elements, AliceServiceSession::used_element_count, GNUNET_CRYPTO_EccScalar::v, and MpiElement::value.

Referenced by cb_intersection_element_removed().

Here is the call graph for this function:
Here is the caller 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 should be removed from the result set, and then once to indicate that the set intersection operation is done.

Parameters
clsclosure with the struct AliceServiceSession
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 645 of file gnunet-service-scalarproduct-ecc_alice.c.

649 {
650  struct AliceServiceSession *s = cls;
651  struct GNUNET_SCALARPRODUCT_Element *se;
652 
653  switch (status)
654  {
656  /* this element has been removed from the set */
658  element->data);
659  GNUNET_assert (NULL != se);
661  "Intersection removed element with key %s and value %lld\n",
662  GNUNET_h2s (&se->key),
663  (long long) GNUNET_ntohll (se->value));
664  GNUNET_assert (
665  GNUNET_YES ==
667  element->data,
668  se));
669  GNUNET_free (se);
670  return;
672  s->intersection_op = NULL;
673  if (NULL != s->intersection_set)
674  {
676  s->intersection_set = NULL;
677  }
679  return;
681  /* unhandled status code */
682  LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
683  if (NULL != s->intersection_listen)
684  {
686  s->intersection_listen = NULL;
687  }
688  s->intersection_op = NULL;
689  if (NULL != s->intersection_set)
690  {
692  s->intersection_set = NULL;
693  }
696  return;
697 
698  default:
699  GNUNET_break (0);
700  return;
701  }
702 }
uint16_t status
See PRISM_STATUS_*-constants.
static void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
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.
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.
@ 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.
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 void * data
Actual data of the element.

References GNUNET_SETI_Element::data, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_destroy(), GNUNET_SETI_listen_cancel(), GNUNET_SETI_STATUS_DEL_LOCAL, GNUNET_SETI_STATUS_DONE, GNUNET_SETI_STATUS_FAILURE, GNUNET_YES, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_listen, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), AliceServiceSession::s, send_alices_cryptodata_message(), AliceServiceSession::status, status, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by cb_intersection_request_alice().

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

◆ cb_intersection_request_alice()

static void cb_intersection_request_alice ( void *  cls,
const struct GNUNET_PeerIdentity other_peer,
const struct GNUNET_MessageHeader context_msg,
struct GNUNET_SETI_Request request 
)
static

Called when another peer wants to do a set operation with the local peer.

If a listen error occurs, the request is NULL.

Parameters
clsclosure with the struct AliceServiceSession *
other_peerthe other peer
context_msgmessage with application specific information from the other peer
requestrequest from the other peer (never NULL), use GNUNET_SETI_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, which sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 721 of file gnunet-service-scalarproduct-ecc_alice.c.

725 {
726  struct AliceServiceSession *s = cls;
727 
729  "Received intersection request from %s!\n",
730  GNUNET_i2s (other_peer));
731  if (0 != GNUNET_memcmp (other_peer,
732  &s->peer))
733  {
734  GNUNET_break_op (0);
735  return;
736  }
737  s->intersection_op
739  (struct GNUNET_SETI_Option[]){ { 0 } },
741  s);
742  if (NULL == s->intersection_op)
743  {
744  GNUNET_break (0);
747  return;
748  }
749  if (GNUNET_OK !=
750  GNUNET_SETI_commit (s->intersection_op,
751  s->intersection_set))
752  {
753  GNUNET_break (0);
756  return;
757  }
758 }
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
Callback for set operation results.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_accept(struct GNUNET_SETI_Request *request, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SETI_listen().
Definition: seti_api.c:780
int GNUNET_SETI_commit(struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
Commit a set to be used with a set operation.
Definition: seti_api.c:836
Option for set operations.

References cb_intersection_element_removed(), GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_accept(), GNUNET_SETI_commit(), prepare_client_end_notification(), request, and AliceServiceSession::s.

Referenced by client_request_complete_alice().

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

◆ client_request_complete_alice()

static void client_request_complete_alice ( struct AliceServiceSession s)
static

Our client has finished sending us its multipart message.

Parameters
sessionthe service session context

Definition at line 767 of file gnunet-service-scalarproduct-ecc_alice.c.

768 {
769  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
770  GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
773  s),
775  };
777  struct GNUNET_MQ_Envelope *e;
778  struct GNUNET_HashCode set_sid;
779 
781  sizeof(struct GNUNET_HashCode),
782  &set_sid);
784  "Creating new channel for session with key %s.\n",
785  GNUNET_h2s (&s->session_id));
787  s,
788  &s->peer,
789  &s->session_id,
790  NULL,
792  cadet_handlers);
793  if (NULL == s->channel)
794  {
797  return;
798  }
801  &set_sid,
803  s);
804  if (NULL == s->intersection_listen)
805  {
808  s->channel = NULL;
810  return;
811  }
812 
813  e =
817  msg->session_id = s->session_id;
818  GNUNET_MQ_send (s->cadet_mq, e);
819 }
static void cb_intersection_request_alice(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
Called when another peer wants to do a set operation with the local peer.
static struct GNUNET_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_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1031
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1082
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1022
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
@ GNUNET_MQ_PRIO_CRITICAL_CONTROL
Highest priority, control traffic (e.g.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
struct GNUNET_SETI_ListenHandle * GNUNET_SETI_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETI_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: seti_api.c:715
struct GNUNET_PeerIdentity peer
Alice or Bob's peerID.
Message type passed from responding service Bob to responding service Alice to complete a request and...
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
A 512-bit hashcode.
Message handler for a specific message type.

References AliceServiceSession::cadet_mq, cb_channel_destruction(), cb_intersection_request_alice(), cfg, AliceServiceSession::channel, e, GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_get_mq(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION, GNUNET_MQ_env_set_options(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_MQ_send(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_listen(), AliceServiceSession::intersection_listen, msg, my_cadet, AliceServiceSession::peer, prepare_client_end_notification(), AliceServiceSession::session_id, and AliceServiceSession::status.

Referenced by handle_alice_client_message(), and handle_alice_client_message_multipart().

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

◆ check_alice_client_message_multipart()

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

We're receiving additional set data.

Check if msg is well-formed.

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

Definition at line 831 of file gnunet-service-scalarproduct-ecc_alice.c.

834 {
835  struct AliceServiceSession *s = cls;
836  uint32_t contained_count;
837  uint16_t msize;
838 
839  msize = ntohs (msg->header.size);
840  contained_count = ntohl (msg->element_count_contained);
841  if ((msize !=
843  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
844  (0 == contained_count) ||
845  (s->total == s->client_received_element_count) ||
846  (s->total < s->client_received_element_count + contained_count))
847  {
848  GNUNET_break_op (0);
849  return GNUNET_SYSERR;
850  }
851  return GNUNET_OK;
852 }
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
multipart messages following struct ComputationMessage
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, msg, AliceServiceSession::s, and GNUNET_MessageHeader::size.

◆ handle_alice_client_message_multipart()

static void handle_alice_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
clsclient identification of the client
msgthe actual message

Definition at line 863 of file gnunet-service-scalarproduct-ecc_alice.c.

866 {
867  struct AliceServiceSession *s = cls;
868  uint32_t contained_count;
869  const struct GNUNET_SCALARPRODUCT_Element *elements;
870  struct GNUNET_SETI_Element set_elem;
871  struct GNUNET_SCALARPRODUCT_Element *elem;
872 
873  contained_count = ntohl (msg->element_count_contained);
874  s->client_received_element_count += contained_count;
875  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
876  for (uint32_t i = 0; i < contained_count; i++)
877  {
879  GNUNET_memcpy (elem,
880  &elements[i],
881  sizeof(struct GNUNET_SCALARPRODUCT_Element));
884  &elem->key,
885  elem,
887  {
888  GNUNET_break (0);
889  GNUNET_free (elem);
890  continue;
891  }
892  set_elem.data = &elem->key;
893  set_elem.size = sizeof(elem->key);
894  set_elem.element_type = 0;
895  GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
896  s->used_element_count++;
897  }
900  {
901  /* more to come */
903  "Received client multipart data, waiting for more!\n");
904  return;
905  }
906  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
908 }
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
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.
@ 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:2244
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
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
uint32_t client_received_element_count
Already transferred elements from client to us.
Element stored in a set.

References AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SETI_add_element(), GNUNET_SYSERR, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, AliceServiceSession::s, GNUNET_SETI_Element::size, AliceServiceSession::total, and AliceServiceSession::used_element_count.

Here is the call graph for this function:

◆ check_alice_client_message()

static int check_alice_client_message ( void *  cls,
const struct AliceComputationMessage msg 
)
static

Handler for Alice's client request message.

Check that msg is well-formed.

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

Definition at line 920 of file gnunet-service-scalarproduct-ecc_alice.c.

922 {
923  struct AliceServiceSession *s = cls;
924  uint16_t msize;
925  uint32_t total_count;
926  uint32_t contained_count;
927 
928  if (NULL != s->intersected_elements)
929  {
930  /* only one concurrent session per client connection allowed,
931  simplifies logic a lot... */
932  GNUNET_break (0);
933  return GNUNET_SYSERR;
934  }
935  msize = ntohs (msg->header.size);
936  total_count = ntohl (msg->element_count_total);
937  contained_count = ntohl (msg->element_count_contained);
938  if ((0 == total_count) || (0 == contained_count) ||
939  (msize !=
940  (sizeof(struct AliceComputationMessage)
941  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
942  {
943  GNUNET_break_op (0);
944  return GNUNET_SYSERR;
945  }
946  return GNUNET_OK;
947 }
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:46

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

◆ handle_alice_client_message()

static void handle_alice_client_message ( void *  cls,
const struct AliceComputationMessage msg 
)
static

Handler for Alice's client request message.

We are doing request-initiation to compute a scalar product with a peer.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 958 of file gnunet-service-scalarproduct-ecc_alice.c.

960 {
961  struct AliceServiceSession *s = cls;
962  uint32_t contained_count;
963  uint32_t total_count;
964  const struct GNUNET_SCALARPRODUCT_Element *elements;
965  struct GNUNET_SETI_Element set_elem;
966  struct GNUNET_SCALARPRODUCT_Element *elem;
967 
968  total_count = ntohl (msg->element_count_total);
969  contained_count = ntohl (msg->element_count_contained);
970  s->peer = msg->peer;
972  s->total = total_count;
973  s->client_received_element_count = contained_count;
974  s->session_id = msg->session_key;
975  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
978  GNUNET_YES);
980  for (uint32_t i = 0; i < contained_count; i++)
981  {
982  if (0 == GNUNET_ntohll (elements[i].value))
983  continue;
985  *elem = elements[i];
986  if (GNUNET_SYSERR ==
989  &elem->key,
990  elem,
992  {
993  /* element with same key encountered twice! */
994  GNUNET_break (0);
995  GNUNET_free (elem);
996  continue;
997  }
998  set_elem.data = &elem->key;
999  set_elem.size = sizeof(elem->key);
1000  set_elem.element_type = 0;
1002  &set_elem,
1003  NULL,
1004  NULL);
1005  s->used_element_count++;
1006  }
1008  if (s->total != s->client_received_element_count)
1009  {
1010  /* wait for multipart msg */
1012  "Received partial client request, waiting for more!\n");
1013  return;
1014  }
1016  "Launching computation\n");
1018 }
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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

References cfg, AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SETI_add_element(), GNUNET_SETI_create(), GNUNET_SYSERR, GNUNET_YES, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, AliceServiceSession::peer, AliceServiceSession::s, AliceServiceSession::session_id, GNUNET_SETI_Element::size, AliceServiceSession::status, AliceServiceSession::total, AliceServiceSession::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
tcunused

Definition at line 1028 of file gnunet-service-scalarproduct-ecc_alice.c.

1029 {
1031  "Shutting down, initiating cleanup.\n");
1032  // FIXME: we have to cut our connections to CADET first!
1033  if (NULL != my_cadet)
1034  {
1036  my_cadet = NULL;
1037  }
1038  if (NULL != edc)
1039  {
1041  edc = NULL;
1042  }
1043 }
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:775

References edc, GNUNET_CADET_disconnect(), GNUNET_CRYPTO_ecc_dlog_release(), 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 AliceServiceSession

Definition at line 1057 of file gnunet-service-scalarproduct-ecc_alice.c.

1060 {
1061  struct AliceServiceSession *s;
1062 
1063  s = GNUNET_new (struct AliceServiceSession);
1064  s->client = client;
1065  s->client_mq = mq;
1066  return s;
1067 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5

References AliceServiceSession::client, GNUNET_new, mq, and AliceServiceSession::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 AliceServiceSession

Definition at line 1081 of file gnunet-service-scalarproduct-ecc_alice.c.

1084 {
1085  struct AliceServiceSession *s = app_cls;
1086 
1088  "Client %p disconnected from us.\n",
1089  client);
1090  s->client = NULL;
1091  s->client_mq = NULL;
1093 }

References AliceServiceSession::client, destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and AliceServiceSession::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 1104 of file gnunet-service-scalarproduct-ecc_alice.c.

1107 {
1108  cfg = c;
1110  MAX_RAM);
1111  /* Select a random 'a' value for Alice */
1113  &my_privkey_inv);
1115  if (NULL == my_cadet)
1116  {
1118  _ ("Connect to CADET failed\n"));
1120  return;
1121  }
1123  NULL);
1124 }
#define MAX_RAM
How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes t...
static void shutdown_task(void *cls)
Task run during shutdown.
#define MAX_RESULT
Maximum allowed result value for the scalarproduct computation.
void GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccScalar *r, struct GNUNET_CRYPTO_EccScalar *r_neg)
Obtain a random scalar for point multiplication on the curve and its additive inverse.
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:910
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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:1331
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, cfg, edc, GNUNET_CADET_connect(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_CRYPTO_ecc_rnd_mpi(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), MAX_RAM, MAX_RESULT, my_cadet, my_privkey, my_privkey_inv, and shutdown_task().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "scalarproduct-alice"  ,
GNUNET_SERVICE_OPTION_NONE  ,
run,
client_connect_cb,
client_disconnect_cb,
NULL  ,
GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL)  ,
GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL)  ,
GNUNET_MQ_handler_end()   
)

Define "main" method using service macro.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

GNUnet configuration handle.

Definition at line 183 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by client_request_complete_alice(), handle_alice_client_message(), and run().

◆ edc

struct GNUNET_CRYPTO_EccDlogContext* edc
static

◆ my_privkey

struct GNUNET_CRYPTO_EccScalar my_privkey
static

Alice's private key ('a').

Definition at line 188 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by run(), and send_alices_cryptodata_message().

◆ my_privkey_inv

struct GNUNET_CRYPTO_EccScalar my_privkey_inv
static

Inverse of Alice's private key ('a_inv').

Definition at line 188 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by handle_bobs_cryptodata_message(), and run().

◆ my_cadet

struct GNUNET_CADET_Handle* my_cadet
static

Handle to the CADET service.

Definition at line 203 of file gnunet-service-scalarproduct-ecc_alice.c.

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