GNUnet  0.10.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_set_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   ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof (struct EccAliceCryptodataMessage)) / sizeof (struct GNUNET_CRYPTO_EccPoint))
 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 gcry_mpi_t compute_scalar_product (struct AliceServiceSession *session, gcry_mpi_point_t prod_g_i_b_i, gcry_mpi_point_t prod_h_i_b_i)
 Compute our scalar product, done by Alice. 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_SET_Element *element, uint64_t current_size, enum GNUNET_SET_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_SET_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 gcry_mpi_t my_privkey
 Alice's private key ('a'). More...
 
static gcry_mpi_t 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__)

◆ 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 46 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by run().

◆ 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 54 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by run().

◆ ELEMENT_CAPACITY

#define ELEMENT_CAPACITY   ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof (struct EccAliceCryptodataMessage)) / sizeof (struct GNUNET_CRYPTO_EccPoint))

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

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

Referenced by send_alices_cryptodata_message().

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 217 of file gnunet-service-scalarproduct-ecc_alice.c.

References e, GNUNET_free, GNUNET_OK, and MpiElement::value.

Referenced by destroy_service_session().

220 {
222 
223  GNUNET_free (e);
224  return GNUNET_OK;
225 }
static struct Experiment * e
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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 AliceServiceSession s)
static

Destroy session state, we are done with it.

Parameters
sthe session to free elements from

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

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_SET_destroy(), GNUNET_SET_listen_cancel(), GNUNET_SET_operation_cancel(), GNUNET_YES, AliceServiceSession::in_destroy, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_listen, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, LOG, AliceServiceSession::product, AliceServiceSession::sorted_elements, AliceServiceSession::used_element_count, and MpiElement::value.

Referenced by client_disconnect_cb(), and handle_bobs_cryptodata_message().

235 {
236  unsigned int i;
237 
238  if (GNUNET_YES == s->in_destroy)
239  return;
240  s->in_destroy = GNUNET_YES;
241  if (NULL != s->client)
242  {
243  struct GNUNET_SERVICE_Client *c = s->client;
244 
245  s->client = NULL;
247  }
248  if (NULL != s->channel)
249  {
251  s->channel = NULL;
252  }
253  if (NULL != s->intersected_elements)
254  {
257  s);
259  s->intersected_elements = NULL;
260  }
261  if (NULL != s->intersection_listen)
262  {
264  s->intersection_listen = NULL;
265  }
266  if (NULL != s->intersection_op)
267  {
269  "Set intersection, op still ongoing!\n");
271  s->intersection_op = NULL;
272  }
273  if (NULL != s->intersection_set)
274  {
276  s->intersection_set = NULL;
277  }
278  if (NULL != s->sorted_elements)
279  {
280  for (i=0;i<s->used_element_count;i++)
281  gcry_mpi_release (s->sorted_elements[i].value);
283  s->sorted_elements = NULL;
284  }
285  if (NULL != s->product)
286  {
287  gcry_mpi_release (s->product);
288  s->product = NULL;
289  }
290  GNUNET_free (s);
291 }
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
gcry_mpi_t value
a_i value, not disclosed to Bob.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
Handle to a client that is connected to a service.
Definition: service.c:249
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:771
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called to free elements.
void GNUNET_SET_listen_cancel(struct GNUNET_SET_ListenHandle *lh)
Cancel the given listen operation.
Definition: set_api.c:1047
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
gcry_mpi_t product
The computed scalar.
void GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh)
Cancel the given set operation.
Definition: set_api.c:515
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_SET_ListenHandle * intersection_listen
Handle to Alice&#39;s Intersection operation listening for Bob.
#define LOG(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:911
#define GNUNET_free(ptr)
Wrapper around free.
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 301 of file gnunet-service-scalarproduct-ecc_alice.c.

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, ClientResponseMessage::product_length, AliceServiceSession::session_id, ClientResponseMessage::status, and AliceServiceSession::status.

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

302 {
303  struct ClientResponseMessage *msg;
304  struct GNUNET_MQ_Envelope *e;
305 
306  if (NULL == session->client_mq)
307  return; /* no client left to be notified */
309  "Sending session-end notification with status %d to client for session %s\n",
310  session->status,
311  GNUNET_h2s (&session->session_id));
312  e = GNUNET_MQ_msg (msg,
314  msg->product_length = htonl (0);
315  msg->status = htonl (session->status);
316  GNUNET_MQ_send (session->client_mq,
317  e);
318 }
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#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).
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
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:353
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
#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:

◆ 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 328 of file gnunet-service-scalarproduct-ecc_alice.c.

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, LOG_GCRY, msg, prepare_client_end_notification(), AliceServiceSession::product, ClientResponseMessage::product_length, ClientResponseMessage::range, AliceServiceSession::session_id, ClientResponseMessage::status, and MpiElement::value.

Referenced by handle_bobs_cryptodata_message().

329 {
330  struct ClientResponseMessage *msg;
331  struct GNUNET_MQ_Envelope *e;
332  unsigned char *product_exported = NULL;
333  size_t product_length = 0;
334  int32_t range;
335  gcry_error_t rc;
336  int sign;
337  gcry_mpi_t value;
338 
339  if (NULL == s->product)
340  {
341  GNUNET_break (0);
343  return;
344  }
345  value = gcry_mpi_new (0);
346  sign = gcry_mpi_cmp_ui (s->product, 0);
347  if (0 > sign)
348  {
349  range = -1;
350  gcry_mpi_sub (value,
351  value,
352  s->product);
353  }
354  else if (0 < sign)
355  {
356  range = 1;
357  gcry_mpi_add (value, value, s->product);
358  }
359  else
360  {
361  /* result is exactly zero */
362  range = 0;
363  }
364  gcry_mpi_release (s->product);
365  s->product = NULL;
366 
367  if ( (0 != range) &&
368  (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
369  &product_exported,
370  &product_length,
371  value))))
372  {
374  "gcry_mpi_scan",
375  rc);
377  return;
378  }
379  gcry_mpi_release (value);
380  e = GNUNET_MQ_msg_extra (msg,
381  product_length,
384  msg->range = htonl (range);
385  msg->product_length = htonl (product_length);
386  if (NULL != product_exported)
387  {
388  GNUNET_memcpy (&msg[1],
389  product_exported,
390  product_length);
391  GNUNET_free (product_exported);
392  }
394  e);
396  "Sent result to client, session %s has ended!\n",
397  GNUNET_h2s (&s->session_id));
398 }
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
#define LOG_GCRY(level, cmd, rc)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
Definition: scalarproduct.h:35
static struct Experiment * e
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
#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
#define GNUNET_memcpy(dst, src, n)
static char * value
Value of the record to add/remove.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
uint32_t product_length
0 if no product attached
gcry_mpi_t product
The computed scalar.
#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:353
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_free(ptr)
Wrapper around free.
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 411 of file gnunet-service-scalarproduct-ecc_alice.c.

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

Referenced by client_request_complete_alice().

413 {
414  struct AliceServiceSession *s = cls;
415 
417  "Peer disconnected, terminating session %s with peer %s\n",
418  GNUNET_h2s (&s->session_id),
419  GNUNET_i2s (&s->peer));
420  s->channel = NULL;
422  {
423  /* We didn't get an answer yet, fail with error */
426  }
427 }
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
Operation is still active (never returned, used internally).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_PeerIdentity peer
Alice or Bob&#39;s peerID.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ compute_scalar_product()

static gcry_mpi_t compute_scalar_product ( struct AliceServiceSession session,
gcry_mpi_point_t  prod_g_i_b_i,
gcry_mpi_point_t  prod_h_i_b_i 
)
static

Compute our scalar product, done by Alice.

Parameters
sessionthe session associated with this computation
prod_g_i_b_ivalue from Bob
prod_h_i_b_ivalue from Bob
Returns
product as MPI, never NULL

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

References GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_dlog(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, INT_MAX, my_privkey_inv, and ret.

Referenced by handle_bobs_cryptodata_message().

442 {
443  gcry_mpi_point_t g_i_b_i_a_inv;
444  gcry_mpi_point_t g_ai_bi;
445  int ai_bi;
446  gcry_mpi_t ret;
447 
448  g_i_b_i_a_inv = GNUNET_CRYPTO_ecc_pmul_mpi (edc,
449  prod_g_i_b_i,
451  g_ai_bi = GNUNET_CRYPTO_ecc_add (edc,
452  g_i_b_i_a_inv,
453  prod_h_i_b_i);
454  gcry_mpi_point_release (g_i_b_i_a_inv);
455  ai_bi = GNUNET_CRYPTO_ecc_dlog (edc,
456  g_ai_bi);
457  gcry_mpi_point_release (g_ai_bi);
458  if (INT_MAX == ai_bi)
459  {
460  /* result too big */
462  "Scalar product result out of range\n");
463  return NULL;
464  }
465  ret = gcry_mpi_new (0);
466  if (ai_bi > 0)
467  {
468  gcry_mpi_set_ui (ret, ai_bi);
469  }
470  else
471  {
472  gcry_mpi_set_ui (ret, - ai_bi);
473  gcry_mpi_neg (ret, ret);
474  }
475  return ret;
476 }
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define INT_MAX
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_add(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t a, gcry_mpi_point_t b)
Add two points on the elliptic curve.
#define GNUNET_log(kind,...)
static gcry_mpi_t my_privkey_inv
Inverse of Alice&#39;s private key (&#39;a_inv&#39;).
int GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t input)
Calculate ECC discrete logarithm for small factors.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_pmul_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t p, gcry_mpi_t val)
Multiply the point p on the elliptic curve by val.
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 487 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceServiceSession::channel, AliceServiceSession::client_received_element_count, compute_scalar_product(), EccBobCryptodataMessage::contained_element_count, destroy_service_session(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_ecc_bin_to_point(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, EccBobCryptodataMessage::prod_g_i_b_i, EccBobCryptodataMessage::prod_h_i_b_i, AliceServiceSession::product, AliceServiceSession::s, AliceServiceSession::sorted_elements, AliceServiceSession::total, and transmit_client_response().

489 {
490  struct AliceServiceSession *s = cls;
491  gcry_mpi_point_t prod_g_i_b_i;
492  gcry_mpi_point_t prod_h_i_b_i;
493  uint32_t contained;
494 
495  contained = ntohl (msg->contained_element_count);
496  if (2 != contained)
497  {
498  GNUNET_break_op (0);
500  return;
501  }
502  if (NULL == s->sorted_elements)
503  {
504  /* we're not ready yet, how can Bob be? */
505  GNUNET_break_op (0);
507  return;
508  }
510  {
511  /* we're not ready yet, how can Bob be? */
512  GNUNET_break_op (0);
514  return;
515  }
516 
518  "Received %u crypto values from Bob\n",
519  (unsigned int) contained);
521  prod_g_i_b_i = GNUNET_CRYPTO_ecc_bin_to_point (edc,
522  &msg->prod_g_i_b_i);
523  prod_h_i_b_i = GNUNET_CRYPTO_ecc_bin_to_point (edc,
524  &msg->prod_h_i_b_i);
526  prod_g_i_b_i,
527  prod_h_i_b_i);
528  gcry_mpi_point_release (prod_g_i_b_i);
529  gcry_mpi_point_release (prod_h_i_b_i);
531 }
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
The product of the g_i^{b_i} values.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_bin_to_point(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *bin)
Convert binary representation of a point to computational representation.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
static void transmit_client_response(struct AliceServiceSession *s)
Prepare the final (positive) response we will send to Alice&#39;s client.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
The product of the h_i^{b_i} values.
uint32_t contained_element_count
How many elements this individual message delivers (in NBO), always TWO.
gcry_mpi_t product
The computed scalar.
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:973
static gcry_mpi_t compute_scalar_product(struct AliceServiceSession *session, gcry_mpi_point_t prod_g_i_b_i, gcry_mpi_point_t prod_h_i_b_i)
Compute our scalar product, done by Alice.
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t client_received_element_count
Already transferred elements from client to us.
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
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 543 of file gnunet-service-scalarproduct-ecc_alice.c.

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

Referenced by send_alices_cryptodata_message().

546 {
547  struct AliceServiceSession *s = cls;
549  gcry_mpi_t mval;
550  int64_t val;
551 
552  mval = gcry_mpi_new (0);
553  val = (int64_t) GNUNET_ntohll (e->value);
554  if (0 > val)
555  gcry_mpi_sub_ui (mval, mval, -val);
556  else
557  gcry_mpi_add_ui (mval, mval, val);
560  s->used_element_count++;
561  return GNUNET_OK;
562 }
A scalarproduct session which tracks a request form the client to our final response.
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:78
gcry_mpi_t value
a_i value, not disclosed to Bob.
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
static char * value
Value of the record to add/remove.
int64_t value
Value to multiply in scalar product, in NBO.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
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.

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

References GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by send_alices_cryptodata_message().

575 {
576  const struct MpiElement *ma = a;
577  const struct MpiElement *mb = b;
578 
579  return GNUNET_CRYPTO_hash_cmp (ma->key,
580  mb->key);
581 }
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:

◆ 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 598 of file gnunet-service-scalarproduct-ecc_alice.c.

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

Referenced by cb_intersection_element_removed().

599 {
601  struct GNUNET_MQ_Envelope *e;
603  gcry_mpi_t r_ia;
604  gcry_mpi_t r_ia_ai;
605  unsigned int i;
606  unsigned int off;
607  unsigned int todo_count;
608 
609  s->sorted_elements
611  struct MpiElement);
612  s->used_element_count = 0;
615  s);
617  "Finished intersection, %d items remain\n",
618  s->used_element_count);
619  qsort (s->sorted_elements,
621  sizeof (struct MpiElement),
622  &element_cmp);
623  off = 0;
624  while (off < s->used_element_count)
625  {
626  todo_count = s->used_element_count - off;
627  if (todo_count > ELEMENT_CAPACITY)
628  todo_count = ELEMENT_CAPACITY;
630  "Sending %u/%u crypto values to Bob\n",
631  (unsigned int) todo_count,
632  (unsigned int) s->used_element_count);
633 
634  e = GNUNET_MQ_msg_extra (msg,
635  todo_count * 2 * sizeof (struct GNUNET_CRYPTO_EccPoint),
637  msg->contained_element_count = htonl (todo_count);
638  payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
639  r_ia = gcry_mpi_new (0);
640  r_ia_ai = gcry_mpi_new (0);
641  for (i = off; i < off + todo_count; i++)
642  {
643  gcry_mpi_t r_i;
644  gcry_mpi_point_t g_i;
645  gcry_mpi_point_t h_i;
646 
649  r_i);
650  /* r_ia = r_i * a */
651  gcry_mpi_mul (r_ia,
652  r_i,
653  my_privkey);
654  gcry_mpi_release (r_i);
655  /* r_ia_ai = r_ia + a_i */
656  gcry_mpi_add (r_ia_ai,
657  r_ia,
658  s->sorted_elements[i].value);
660  r_ia_ai);
662  g_i,
663  &payload[(i - off) * 2]);
665  h_i,
666  &payload[(i - off) * 2 + 1]);
667  gcry_mpi_point_release (g_i);
668  gcry_mpi_point_release (h_i);
669  }
670  gcry_mpi_release (r_ia);
671  gcry_mpi_release (r_ia_ai);
672  off += todo_count;
674  e);
675  }
676 }
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
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)...
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
gcry_mpi_t GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccDlogContext *edc)
Generate a random value mod n.
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 GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
static struct Experiment * e
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
gcry_mpi_t value
a_i value, not disclosed to Bob.
void GNUNET_CRYPTO_ecc_point_to_bin(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t point, struct GNUNET_CRYPTO_EccPoint *bin)
Convert point value to binary representation.
#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
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
An encrypted element key-value pair.
static gcry_mpi_t my_privkey
Alice&#39;s private key (&#39;a&#39;).
static unsigned long long payload
How much data are we currently storing in the database?
gcry_mpi_point_t GNUNET_CRYPTO_ecc_dexp_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_t val)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
#define GNUNET_log(kind,...)
#define ELEMENT_CAPACITY
Maximum number of elements we can put into a single cryptodata message.
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:353
#define LOG(kind,...)
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
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_SET_Element element,
uint64_t  current_size,
enum GNUNET_SET_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_SET_STATUS_OK
current_sizecurrent set size
statuswhat has happened with the set intersection?

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

References GNUNET_SET_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_SET_destroy(), GNUNET_SET_listen_cancel(), GNUNET_SET_STATUS_DONE, GNUNET_SET_STATUS_FAILURE, GNUNET_SET_STATUS_HALF_DONE, GNUNET_SET_STATUS_OK, 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, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by cb_intersection_request_alice().

694 {
695  struct AliceServiceSession *s = cls;
696  struct GNUNET_SCALARPRODUCT_Element *se;
697 
698  switch (status)
699  {
701  /* this element has been removed from the set */
703  element->data);
704  GNUNET_assert (NULL != se);
706  "Intersection removed element with key %s and value %lld\n",
707  GNUNET_h2s (&se->key),
708  (long long) GNUNET_ntohll (se->value));
711  element->data,
712  se));
713  GNUNET_free (se);
714  return;
716  s->intersection_op = NULL;
717  if (NULL != s->intersection_set)
718  {
720  s->intersection_set = NULL;
721  }
723  return;
725  /* unexpected for intersection */
726  GNUNET_break (0);
727  return;
729  /* unhandled status code */
731  "Set intersection failed!\n");
732  if (NULL != s->intersection_listen)
733  {
735  s->intersection_listen = NULL;
736  }
737  s->intersection_op = NULL;
738  if (NULL != s->intersection_set)
739  {
741  s->intersection_set = NULL;
742  }
745  return;
746  default:
747  GNUNET_break (0);
748  return;
749  }
750 }
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
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.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
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:771
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...
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.
void GNUNET_SET_listen_cancel(struct GNUNET_SET_ListenHandle *lh)
Cancel the given listen operation.
Definition: set_api.c:1047
int64_t value
Value to multiply in scalar product, in NBO.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_SET_ListenHandle * intersection_listen
Handle to Alice&#39;s Intersection operation listening for Bob.
#define LOG(kind,...)
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
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:
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_SET_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_SET_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, whith sometimes can be derived from the context message. It's necessary to specify the timeout.

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

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_SET_accept(), GNUNET_SET_commit(), GNUNET_SET_RESULT_REMOVED, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, AliceServiceSession::peer, prepare_client_end_notification(), AliceServiceSession::s, and AliceServiceSession::status.

Referenced by client_request_complete_alice().

773 {
774  struct AliceServiceSession *s = cls;
775 
777  "Received intersection request from %s!\n",
778  GNUNET_i2s (other_peer));
779  if (0 != GNUNET_memcmp (other_peer,
780  &s->peer))
781  {
782  GNUNET_break_op (0);
783  return;
784  }
785  s->intersection_op
786  = GNUNET_SET_accept (request,
788  (struct GNUNET_SET_Option[]) {{ 0 }},
790  s);
791  if (NULL == s->intersection_op)
792  {
793  GNUNET_break (0);
796  return;
797  }
798  if (GNUNET_OK !=
800  s->intersection_set))
801  {
802  GNUNET_break (0);
805  return;
806  }
807 }
A scalarproduct session which tracks a request form the client to our final response.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_PeerIdentity peer
Alice or Bob&#39;s peerID.
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.
Option for set operations.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
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:1124
#define GNUNET_log(kind,...)
Client gets only elements that have been removed from the set.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
struct GNUNET_SET_OperationHandle * GNUNET_SET_accept(struct GNUNET_SET_Request *request, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SET_listen().
Definition: set_api.c:1081
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 816 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceServiceSession::cadet_mq, cb_channel_destruction(), cb_intersection_request_alice(), AliceServiceSession::channel, e, GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_get_mq(), GNUNET_CADET_OPTION_RELIABLE, 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_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SET_listen(), GNUNET_SET_OPERATION_INTERSECTION, AliceServiceSession::intersection_listen, msg, AliceServiceSession::peer, prepare_client_end_notification(), EccServiceRequestMessage::session_id, AliceServiceSession::session_id, and AliceServiceSession::status.

Referenced by handle_alice_client_message(), and handle_alice_client_message_multipart().

817 {
818  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
819  GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
822  s),
824  };
826  struct GNUNET_MQ_Envelope *e;
827  struct GNUNET_HashCode set_sid;
828 
830  sizeof (struct GNUNET_HashCode),
831  &set_sid);
833  "Creating new channel for session with key %s.\n",
834  GNUNET_h2s (&s->session_id));
835  s->channel
837  s,
838  &s->peer,
839  &s->session_id,
841  NULL,
843  cadet_handlers);
844  if (NULL == s->channel)
845  {
848  return;
849  }
854  &set_sid,
856  s);
857  if (NULL == s->intersection_listen)
858  {
861  s->channel = NULL;
863  return;
864  }
865 
866  e = GNUNET_MQ_msg (msg,
868  msg->session_id = s->session_id;
870  e);
871 }
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
struct GNUNET_SET_ListenHandle * GNUNET_SET_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op_type, const struct GNUNET_HashCode *app_id, GNUNET_SET_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: set_api.c:1013
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
Enable channel reliability, lost messages will be retransmitted.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
#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).
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
static void cb_intersection_request_alice(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SET_Request *request)
Called when another peer wants to do a set operation with the local peer.
A 512-bit hashcode.
Message handler for a specific message type.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
struct GNUNET_PeerIdentity peer
Alice or Bob&#39;s peerID.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
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...
#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.
#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:353
Set intersection, only return elements that are in both sets.
struct GNUNET_SET_ListenHandle * intersection_listen
Handle to Alice&#39;s Intersection operation listening for Bob.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:911
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
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, enum GNUNET_CADET_ChannelOption options, 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:1088
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:1142
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 883 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceServiceSession::client_received_element_count, ComputationBobCryptodataMultipartMessage::element_count_contained, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, ComputationBobCryptodataMultipartMessage::header, AliceServiceSession::s, GNUNET_MessageHeader::size, and AliceServiceSession::total.

885 {
886  struct AliceServiceSession *s = cls;
887  uint32_t contained_count;
888  uint16_t msize;
889 
890  msize = ntohs (msg->header.size);
891  contained_count = ntohl (msg->element_count_contained);
892  if ( (msize != (sizeof (struct ComputationBobCryptodataMultipartMessage) +
893  contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) ||
894  (0 == contained_count) ||
896  (s->total < s->client_received_element_count + contained_count) )
897  {
898  GNUNET_break_op (0);
899  return GNUNET_SYSERR;
900  }
901  return GNUNET_OK;
902 }
A scalarproduct session which tracks a request form the client to our final response.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_MessageHeader header
GNUNET message header.
uint32_t element_count_contained
contained elements the vector in payload contains
multipart messages following struct ComputationMessage
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t client_received_element_count
Already transferred elements from client to us.
An element key-value pair for scalarproduct.

◆ 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 913 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), 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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SET_add_element(), GNUNET_SYSERR, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, AliceServiceSession::s, GNUNET_SET_Element::size, AliceServiceSession::total, and AliceServiceSession::used_element_count.

915 {
916  struct AliceServiceSession *s = cls;
917  uint32_t contained_count;
918  const struct GNUNET_SCALARPRODUCT_Element *elements;
919  struct GNUNET_SET_Element set_elem;
920  struct GNUNET_SCALARPRODUCT_Element *elem;
921 
922  contained_count = ntohl (msg->element_count_contained);
923  s->client_received_element_count += contained_count;
924  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
925  for (uint32_t i = 0; i < contained_count; i++)
926  {
928  GNUNET_memcpy (elem,
929  &elements[i],
930  sizeof (struct GNUNET_SCALARPRODUCT_Element));
931  if (GNUNET_SYSERR ==
933  &elem->key,
934  elem,
936  {
937  GNUNET_break (0);
938  GNUNET_free (elem);
939  continue;
940  }
941  set_elem.data = &elem->key;
942  set_elem.size = sizeof (elem->key);
943  set_elem.element_type = 0;
945  &set_elem,
946  NULL, NULL);
947  s->used_element_count++;
948  }
951  {
952  /* more to come */
954  "Received client multipart data, waiting for more!\n");
955  return;
956  }
958  "Launching computation\n");
960 }
A scalarproduct session which tracks a request form the client to our final response.
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:686
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
Element stored in a set.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
#define GNUNET_memcpy(dst, src, n)
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:79
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 used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
#define GNUNET_log(kind,...)
uint32_t element_count_contained
contained elements the vector in payload contains
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t client_received_element_count
Already transferred elements from client to us.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
An element key-value pair for scalarproduct.
#define GNUNET_free(ptr)
Wrapper around free.
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 972 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceComputationMessage::element_count_contained, AliceComputationMessage::element_count_total, GNUNET_break, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, AliceComputationMessage::header, AliceServiceSession::intersected_elements, AliceServiceSession::s, and GNUNET_MessageHeader::size.

974 {
975  struct AliceServiceSession *s = cls;
976  uint16_t msize;
977  uint32_t total_count;
978  uint32_t contained_count;
979 
980  if (NULL != s->intersected_elements)
981  {
982  /* only one concurrent session per client connection allowed,
983  simplifies logic a lot... */
984  GNUNET_break (0);
985  return GNUNET_SYSERR;
986  }
987  msize = ntohs (msg->header.size);
988  total_count = ntohl (msg->element_count_total);
989  contained_count = ntohl (msg->element_count_contained);
990  if ( (0 == total_count) ||
991  (0 == contained_count) ||
992  (msize != (sizeof (struct AliceComputationMessage) +
993  contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) )
994  {
995  GNUNET_break_op (0);
996  return GNUNET_SYSERR;
997  }
998  return GNUNET_OK;
999 }
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE.
Definition: scalarproduct.h:48
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:42
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:53
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
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
Definition: scalarproduct.h:58
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
An element key-value pair for scalarproduct.

◆ 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 1010 of file gnunet-service-scalarproduct-ecc_alice.c.

References AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), GNUNET_SET_Element::data, AliceComputationMessage::element_count_contained, AliceComputationMessage::element_count_total, GNUNET_SET_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_memcpy, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SET_add_element(), GNUNET_SET_create(), GNUNET_SET_OPERATION_INTERSECTION, GNUNET_SYSERR, GNUNET_YES, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, AliceComputationMessage::peer, AliceServiceSession::peer, AliceServiceSession::s, AliceServiceSession::session_id, AliceComputationMessage::session_key, GNUNET_SET_Element::size, AliceServiceSession::status, AliceServiceSession::total, AliceServiceSession::used_element_count, and MpiElement::value.

1012 {
1013  struct AliceServiceSession *s = cls;
1014  uint32_t contained_count;
1015  uint32_t total_count;
1016  const struct GNUNET_SCALARPRODUCT_Element *elements;
1017  struct GNUNET_SET_Element set_elem;
1018  struct GNUNET_SCALARPRODUCT_Element *elem;
1019 
1020  total_count = ntohl (msg->element_count_total);
1021  contained_count = ntohl (msg->element_count_contained);
1022  s->peer = msg->peer;
1024  s->total = total_count;
1025  s->client_received_element_count = contained_count;
1026  s->session_id = msg->session_key;
1027  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1029  GNUNET_YES);
1032  for (uint32_t i = 0; i < contained_count; i++)
1033  {
1034  if (0 == GNUNET_ntohll (elements[i].value))
1035  continue;
1036  elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
1037  GNUNET_memcpy (elem,
1038  &elements[i],
1039  sizeof (struct GNUNET_SCALARPRODUCT_Element));
1040  if (GNUNET_SYSERR ==
1042  &elem->key,
1043  elem,
1045  {
1046  /* element with same key encountered twice! */
1047  GNUNET_break (0);
1048  GNUNET_free (elem);
1049  continue;
1050  }
1051  set_elem.data = &elem->key;
1052  set_elem.size = sizeof (elem->key);
1053  set_elem.element_type = 0;
1055  &set_elem,
1056  NULL, NULL);
1057  s->used_element_count++;
1058  }
1060  if (s->total != s->client_received_element_count)
1061  {
1062  /* wait for multipart msg */
1064  "Received partial client request, waiting for more!\n");
1065  return;
1066  }
1068  "Launching computation\n");
1070 }
A scalarproduct session which tracks a request form the client to our final response.
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:686
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
Operation is still active (never returned, used internally).
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
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:656
#define GNUNET_new(type)
Allocate a struct or union of the given type.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
Definition: scalarproduct.h:68
#define GNUNET_memcpy(dst, src, n)
static char * value
Value of the record to add/remove.
struct GNUNET_PeerIdentity peer
the identity of a remote peer we want to communicate with
Definition: scalarproduct.h:73
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:53
struct GNUNET_PeerIdentity peer
Alice or Bob&#39;s peerID.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
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:79
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 used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
#define GNUNET_log(kind,...)
uint32_t element_count_contained
contained elements the vector in payload contains
Definition: scalarproduct.h:58
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:80
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
Set intersection, only return elements that are in both sets.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t client_received_element_count
Already transferred elements from client to us.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
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
tcunused

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

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

Referenced by run().

1081 {
1083  "Shutting down, initiating cleanup.\n");
1084  // FIXME: we have to cut our connections to CADET first!
1085  if (NULL != my_cadet)
1086  {
1088  my_cadet = NULL;
1089  }
1090  if (NULL != edc)
1091  {
1093  edc = NULL;
1094  }
1095 }
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:849
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
#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 AliceServiceSession

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

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

Referenced by run().

1112 {
1113  struct AliceServiceSession *s;
1114 
1115  s = GNUNET_new (struct AliceServiceSession);
1116  s->client = client;
1117  s->client_mq = mq;
1118  return s;
1119 }
A scalarproduct session which tracks a request form the client to our final response.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
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 AliceServiceSession

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

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

Referenced by run().

1136 {
1137  struct AliceServiceSession *s = app_cls;
1138 
1140  "Client %p disconnected from us.\n",
1141  client);
1142  s->client = NULL;
1143  s->client_mq = NULL;
1145 }
A scalarproduct session which tracks a request form the client to our final response.
#define GNUNET_log(kind,...)
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
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 1156 of file gnunet-service-scalarproduct-ecc_alice.c.

References _, client_connect_cb(), client_disconnect_cb(), GNUNET_CADET_connect(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_CRYPTO_ecc_rnd_mpi(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, MAX_RAM, MAX_RESULT, my_privkey, my_privkey_inv, and shutdown_task().

1159 {
1160  cfg = c;
1162  MAX_RAM);
1163  /* Select a random 'a' value for Alice */
1165  &my_privkey,
1166  &my_privkey_inv);
1168  if (NULL == my_cadet)
1169  {
1171  _("Connect to CADET failed\n"));
1173  return;
1174  }
1176  NULL);
1177 
1178 }
void GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_t *r, gcry_mpi_t *r_inv)
Obtain a random scalar for point multiplication on the curve and its multiplicative inverse...
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
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:1293
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static void shutdown_task(void *cls)
Task run during shutdown.
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.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:995
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
#define MAX_RESULT
Maximum allowed result value for the scalarproduct computation.
static gcry_mpi_t my_privkey
Alice&#39;s private key (&#39;a&#39;).
#define GNUNET_log(kind,...)
static gcry_mpi_t my_privkey_inv
Inverse of Alice&#39;s private key (&#39;a_inv&#39;).
#define MAX_RAM
How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes t...
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.

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 185 of file gnunet-service-scalarproduct-ecc_alice.c.

◆ edc

struct GNUNET_CRYPTO_EccDlogContext* edc
static

Context for DLOG operations on a curve.

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

Referenced by GNUNET_CRYPTO_ecc_dlog_prepare().

◆ my_privkey

gcry_mpi_t my_privkey
static

Alice's private key ('a').

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

Referenced by run(), and send_alices_cryptodata_message().

◆ my_privkey_inv

gcry_mpi_t my_privkey_inv
static

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

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

Referenced by compute_scalar_product(), and run().

◆ my_cadet

struct GNUNET_CADET_Handle* my_cadet
static

Handle to the CADET service.

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