pils_api.c File Reference

#include <string.h>
#include <stdint.h>
#include "gnunet_common.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_pils_service.h"
#include "pils.h"

Include dependency graph for pils_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_PILS_Operation
struct	GNUNET_PILS_Handle
	A handle for the PILS service. More...
struct	GNUNET_PILS_KeyRing
	A simplified handle for using the peer identity key. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "pils-api", __VA_ARGS__)

Functions
static void	transmit_op (struct GNUNET_PILS_Operation *op)
	Send the request of op to the service, if we are connected.
static void	flush_ops (struct GNUNET_PILS_Handle *h)
	(Re-)transmit every outstanding request of h.
static struct GNUNET_PILS_Operation *	op_start (struct GNUNET_PILS_Handle *h, struct GNUNET_MessageHeader *req)
	Set up a new operation for h and start transmitting req.
static void	op_destroy (struct GNUNET_PILS_Operation *op)
	Remove op from its handle and free it.
static struct GNUNET_PILS_Operation *	find_op (struct GNUNET_PILS_Handle *h, uint32_t rid)
	Find the op that matches the rid.
static int	check_peer_id (void *cls, const struct PeerIdUpdateMessage *msg)
	Handles sign result.
static void	derive_private_key (struct GNUNET_PILS_Handle *h)
	Re-derive the private key of the current peer identity of h.
static void	handle_peer_id (void *cls, const struct PeerIdUpdateMessage *pid_msg)
	Handles peer ids sent from the service.
static void	handle_sign_result (void *cls, const struct SignResultMessage *msg)
	Handles sign result.
static void	handle_decaps_result (void *cls, const struct DecapsResultMessage *msg)
	Handles decaps result.
static void	handle_ecdh_result (void *cls, const struct EcdhResultMessage *msg)
	Handles ecdh result.
static void	reconnect (void *cls)
	Try again to connect to peer identity lifecycle service.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Handles errors with the mq.
struct GNUNET_PILS_Handle *	GNUNET_PILS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_PILS_PidChangeCallback pid_change_cb, void *cls)
	Connect to the PILS service.
void	GNUNET_PILS_disconnect (struct GNUNET_PILS_Handle *handle)
	Disconnect from the PILS service.
struct GNUNET_PILS_Operation *	GNUNET_PILS_sign_by_peer_identity (struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_SignaturePurpose *purpose, GNUNET_PILS_SignResultCallback cb, void *cb_cls)
	Sign data with the peer id.
struct GNUNET_PILS_Operation *	GNUNET_PILS_kem_decaps (struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_HpkeEncapsulation *c, GNUNET_PILS_DecapsResultCallback cb, void *cb_cls)
	Decaps an encapsulated key with our private key.
struct GNUNET_PILS_Operation *	GNUNET_PILS_ecdh (struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, GNUNET_PILS_EcdhResultCallback cb, void *cb_cls)
	Derive key material from a ECDH public key and our private key.
void	GNUNET_PILS_cancel (struct GNUNET_PILS_Operation *op)
	Cancel request.
void	GNUNET_PILS_derive_pid (size_t seed_key_bytes, const uint8_t seed_key[seed_key_bytes], const struct GNUNET_HashCode *addrs_hash, struct GNUNET_CRYPTO_EddsaPrivateKey *outkey)
	Generate the peer id from the addresses hash and the initial secret key.
void	GNUNET_PILS_feed_addresses (struct GNUNET_PILS_Handle *handle, const struct GNUNET_HELLO_Builder *builder)
	Feed a set of addresses to pils so that it will generate a new peer id based on the given set of addresses.
struct GNUNET_PILS_Operation *	GNUNET_PILS_sign_hello (struct GNUNET_PILS_Handle *handle, const struct GNUNET_HELLO_Builder *builder, struct GNUNET_TIME_Absolute et, GNUNET_PILS_SignResultCallback cb, void *cb_cls)
	Create HELLO signature.
const struct GNUNET_PeerIdentity *	GNUNET_PILS_get_identity (const struct GNUNET_PILS_Handle *handle)
	Return the current peer identity of a given handle.
const struct GNUNET_HashCode *	GNUNET_PILS_get_identity_hash (const struct GNUNET_PILS_Handle *handle)
	Return the hash of the current peer identity from a given handle.
enum GNUNET_GenericReturnValue	GNUNET_PILS_enable_private_key (struct GNUNET_PILS_Handle *handle)
	Enable local access to the private key of the current peer identity.
const struct GNUNET_CRYPTO_EddsaPrivateKey *	GNUNET_PILS_get_private_key (const struct GNUNET_PILS_Handle *handle)
	Return the private key of the current peer identity.
void	pid_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *addr_hash)
struct GNUNET_PILS_KeyRing *	GNUNET_PILS_create_key_ring (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_SCHEDULER_TaskCallback init_cb, void *cls)
	Get the initial secret key for generating the peer id.
void	GNUNET_PILS_destroy_key_ring (struct GNUNET_PILS_KeyRing *key_ring)
	Destroy a key ring handle and free its memory.
const struct GNUNET_CRYPTO_EddsaPrivateKey *	GNUNET_PILS_key_ring_get_private_key (const struct GNUNET_PILS_KeyRing *key_ring)
	Return the current private key of a given key ring handle.

Detailed Description

Author

ch3

Peer Identity Lifecycle Service; the API for managing Peer Identities

This api gives access to the PILS service.

The service maintains the peer identity. On address change it generates a new identity and informs subscribed components. It also signs data with the identity on request.

Definition in file pils_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "pils-api", __VA_ARGS__)

Definition at line 44 of file pils_api.c.

Function Documentation

transmit_op()

static void transmit_op ( struct GNUNET_PILS_Operation *  op )

static

Send the request of op to the service, if we are connected.

A request that cannot be sent right now stays in op_head and is transmitted by flush_ops() once the connection is (re-)established. Note that this must never call GNUNET_MQ_send() on a NULL mq: that asserts, which would take the caller's service down every time an operation is started while PILS happens to be reconnecting.

Parameters

op	operation whose request to transmit

Definition at line 198 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = op->h;
 
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Not connected to PILS, deferring request %u\n",
         (unsigned int) op->op_id);
    return;
  }
  GNUNET_MQ_send (h->mq,
                  GNUNET_MQ_msg_copy (op->req));
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), h, GNUNET_ARM_Operation::h, LOG, GNUNET_ARM_Handle::mq, and op.

Referenced by flush_ops(), GNUNET_PILS_ecdh(), GNUNET_PILS_kem_decaps(), and GNUNET_PILS_sign_by_peer_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

flush_ops()

static void flush_ops ( struct GNUNET_PILS_Handle *  h )

static

(Re-)transmit every outstanding request of h.

Called after a successful (re-)connect. The service is stateless with respect to these requests – it computes an answer and forgets them – so a request that was in flight when the connection broke is simply gone, and without this its callback would never run. Sending it again is safe: the operations are pure functions of the request, and a duplicate answer is dropped by find_op().

Parameters

h	handle whose operations to flush

Definition at line 227 of file pils_api.c.

{
  for (struct GNUNET_PILS_Operation *op = h->op_head;
       NULL != op;
       op = op->next)
    transmit_op (op);
}

References h, GNUNET_ARM_Operation::next, op, and transmit_op().

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

op_start()

static struct GNUNET_PILS_Operation * op_start ( struct GNUNET_PILS_Handle *  h, struct GNUNET_MessageHeader *  req  )

static

Set up a new operation for h and start transmitting req.

Takes ownership of req.

Parameters

h	handle to the PILS service
req	the request message, with rid already filled in

Returns

the new operation

Definition at line 246 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
 
  op = GNUNET_new (struct GNUNET_PILS_Operation);
  op->h = h;
  op->req = req;
  GNUNET_CONTAINER_DLL_insert (h->op_head,
                               h->op_tail,
                               op);
  return op;
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_new, h, GNUNET_ARM_Operation::h, op, and GNUNET_PILS_Operation::req.

Referenced by GNUNET_PILS_ecdh(), GNUNET_PILS_kem_decaps(), and GNUNET_PILS_sign_by_peer_identity().

Here is the caller graph for this function:

op_destroy()

static void op_destroy ( struct GNUNET_PILS_Operation *  op )

static

Remove op from its handle and free it.

Parameters

op	operation to destroy

Definition at line 267 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = op->h;
 
  GNUNET_CONTAINER_DLL_remove (h->op_head,
                               h->op_tail,
                               op);
  GNUNET_free (op->req);
  GNUNET_free (op);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, h, GNUNET_ARM_Operation::h, and op.

Referenced by GNUNET_PILS_cancel(), GNUNET_PILS_disconnect(), handle_decaps_result(), handle_ecdh_result(), and handle_sign_result().

Here is the caller graph for this function:

find_op()

static struct GNUNET_PILS_Operation * find_op ( struct GNUNET_PILS_Handle *  h, uint32_t  rid  )

static

Find the op that matches the rid.

Parameters

h	PILS handle
rid	id to look up

Returns

NULL if rid was not found

Definition at line 287 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
 
  for (op = h->op_head; op != NULL; op = op->next)
    if (op->op_id == rid)
      return op;
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Finding request with id %u was unsuccessful\n",
       rid);
  return NULL;
}

References GNUNET_ERROR_TYPE_WARNING, h, LOG, GNUNET_ARM_Operation::next, and op.

Referenced by handle_decaps_result(), handle_ecdh_result(), and handle_sign_result().

Here is the caller graph for this function:

check_peer_id()

static int check_peer_id ( void *  cls, const struct PeerIdUpdateMessage *  msg  )

static

Handles sign result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the signature

Definition at line 308 of file pils_api.c.

{
  size_t msg_size;
  uint32_t block_bytes;
  (void) cls;
 
  msg_size = ntohs (msg->header.size);
  block_bytes = ntohl (msg->block_len);
  if (msg_size != sizeof (*msg) + block_bytes)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The msg_size (%lu) is not %lu (header) + %u (block)\n",
         msg_size,
         sizeof (*msg),
         block_bytes);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
 
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG, msg, and GNUNET_MessageHeader::size.

derive_private_key()

static void derive_private_key ( struct GNUNET_PILS_Handle *  h )

static

Re-derive the private key of the current peer identity of h.

Does nothing unless local key access was enabled with GNUNET_PILS_enable_private_key(). Must be called after peer_id and hash were updated, and before the application's GNUNET_PILS_PidChangeCallback runs, so that a caller which sees an identity always sees the matching private key.

If the derived key does not belong to the peer identity the service announced, our [PEER]/PRIVATE_KEY does not match the one the service uses. Signing with it would produce signatures nobody can verify, so the key is discarded and callers fall back to asking the service.

Parameters

h	handle to update

Definition at line 347 of file pils_api.c.

{
  struct GNUNET_PeerIdentity pid;
 
  if (! h->have_ikm)
    return;
  if (NULL == h->private_key)
    h->private_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
  GNUNET_PILS_derive_pid (sizeof (h->initial_key_material),
                          h->initial_key_material,
                          &h->hash,
                          h->private_key);
  GNUNET_CRYPTO_eddsa_key_get_public (h->private_key,
                                      &pid.public_key);
  if (0 != GNUNET_memcmp (&pid,
                          h->peer_id))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Locally derived peer identity %s does not match %s announced by the service; check [PEER]/PRIVATE_KEY\n",
         GNUNET_i2s (&pid),
         GNUNET_i2s (h->peer_id));
    GNUNET_CRYPTO_zero_keys (h->private_key,
                             sizeof (*h->private_key));
    GNUNET_free (h->private_key);
    h->private_key = NULL;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Derived private key for peer identity %s\n",
       GNUNET_i2s (h->peer_id));
}

References GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_memcmp, GNUNET_new, GNUNET_PILS_derive_pid(), h, LOG, and GNUNET_PeerIdentity::public_key.

Referenced by GNUNET_PILS_enable_private_key(), and handle_peer_id().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_peer_id()

static void handle_peer_id ( void *  cls, const struct PeerIdUpdateMessage *  pid_msg  )

static

Handles peer ids sent from the service.

Parameters

cls	closure - Handle to the PILS service
pid_msg	the message containing peer id and addresses hash

Definition at line 387 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_HELLO_Parser *parser;
  uint32_t block_bytes;
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  block_bytes = ntohl (pid_msg->block_len);
  parser = GNUNET_HELLO_parser_from_block (&pid_msg[1],
                                           block_bytes);
  if (NULL == parser)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Error parsing Hello block from PILS!\n");
    return;
  }
 
  if (NULL == h->peer_id)
    h->peer_id = GNUNET_new (struct GNUNET_PeerIdentity);
 
  memcpy (&h->hash, &pid_msg->hash, sizeof (struct GNUNET_HashCode));
  memcpy (h->peer_id, GNUNET_HELLO_parser_get_id (parser),
          sizeof (struct GNUNET_PeerIdentity));
  GNUNET_CRYPTO_hash (h->peer_id, sizeof (struct GNUNET_PeerIdentity),
                      &h->peer_hash);
  derive_private_key (h);
 
  if (NULL != h->pid_change_cb)
  {
    h->pid_change_cb (h->pid_change_cb_cls,
                      parser,
                      &pid_msg->hash);
  }
  GNUNET_HELLO_parser_free (parser);
}

References PeerIdUpdateMessage::block_len, derive_private_key(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_block(), GNUNET_HELLO_parser_get_id(), GNUNET_new, GNUNET_TIME_UNIT_ZERO, h, PeerIdUpdateMessage::hash, and LOG.

Here is the call graph for this function:

handle_sign_result()

static void handle_sign_result ( void *  cls, const struct SignResultMessage *  msg  )

static

Handles sign result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the signature

Definition at line 431 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_PILS_Operation *op;
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  op = find_op (h, ntohl (msg->rid));
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received SIGN_RESULT message from service\n");
 
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Didn't find the operation corresponding to id %u\n",
         ntohl (msg->rid));
    return;
  }
  if (NULL != op->sign_cb)
  {
    // FIXME maybe return NULL of key is 0ed
    // as this indicates an error
    op->sign_cb (op->cb_cls,
                 &msg->peer_id,
                 &msg->sig);
  }
  op_destroy (op);
}

References find_op(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_TIME_UNIT_ZERO, h, LOG, msg, op, and op_destroy().

Here is the call graph for this function:

handle_decaps_result()

static void handle_decaps_result ( void *  cls, const struct DecapsResultMessage *  msg  )

static

Handles decaps result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the decapsulation result

Definition at line 468 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_PILS_Operation *op;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received KEM_DECAPS result from service!\n");
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  op = find_op (h, ntohl (msg->rid));
 
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Didn't find the operation corresponding to id %u\n",
         ntohl (msg->rid));
    return;
  }
  if (NULL != op->decaps_cb)
  {
    // FIXME maybe return NULL of key is 0ed
    // as this indicates an error
    op->decaps_cb (op->cb_cls,
                   &msg->key);
  }
  op_destroy (op);
}

References find_op(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_TIME_UNIT_ZERO, h, LOG, msg, op, and op_destroy().

Here is the call graph for this function:

handle_ecdh_result()

static void handle_ecdh_result ( void *  cls, const struct EcdhResultMessage *  msg  )

static

Handles ecdh result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the ecdh result

Definition at line 504 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_PILS_Operation *op;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received ECDH result from service!\n");
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  op = find_op (h, ntohl (msg->rid));
 
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Didn't find the operation corresponding to id %u\n",
         ntohl (msg->rid));
    return;
  }
  if (NULL != op->ecdh_cb)
    op->ecdh_cb (op->cb_cls,
                 &msg->key);
  op_destroy (op);
}

References find_op(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_TIME_UNIT_ZERO, h, LOG, msg, op, and op_destroy().

Here is the call graph for this function:

reconnect()

static void reconnect ( void *  cls )

static

Try again to connect to peer identity lifecycle service.

Parameters

cls	the struct GNUNET_PILS_Handle *

Definition at line 574 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (peer_id,
                           GNUNET_MESSAGE_TYPE_PILS_PEER_ID,
                           struct PeerIdUpdateMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (decaps_result,
                             GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT,
                             struct DecapsResultMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (ecdh_result,
                             GNUNET_MESSAGE_TYPE_PILS_ECDH_RESULT,
                             struct EcdhResultMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (sign_result,
                             GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT,
                             struct SignResultMessage,
                             h),
    GNUNET_MQ_handler_end ()
  };
 
  h->reconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connecting to peer identity lifecycle service.\n");
  GNUNET_assert (NULL == h->mq);
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "pils",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to connect.\n");
    {
      h->reconnect_task =
        GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
      h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
    }
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection to service successful!\n");
  flush_ops (h);
}

References GNUNET_ARM_Handle::cfg, flush_ops(), GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT, GNUNET_MESSAGE_TYPE_PILS_ECDH_RESULT, GNUNET_MESSAGE_TYPE_PILS_PEER_ID, GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), peer_id, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Here is the call graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Handles errors with the mq.

Schedules the reconnect task and updates the reconnect delay.

Parameters

cls	closure - handle to PILS
error	error type indicating the kind of problem with mq

Definition at line 546 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  (void) error;
 
  // TODO logging
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Connection to pils service failed!\n");
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  /* NOTE: @e op_head is deliberately left alone.  The requests in it died
     with the connection, but their callers are still waiting for the
     callbacks -- #flush_ops() re-sends them once we are back.  Dropping
     them here silently (as this used to do) leaves e.g. CORE holding a
     half-finished handshake and a TRANSPORT flow control credit it never
     returns. */
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, LOG, GNUNET_ARM_Handle::mq, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_connect()

struct GNUNET_PILS_Handle * GNUNET_PILS_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_PILS_PidChangeCallback	pid_change_cb,
		void *	cls
	)

Connect to the PILS service.

Parameters

cfg	configuration to use
pid_change_cb	handler/callback called once the peer id changes
cls	closure for pid_change_cb

Returns

Handle to the PILS service

Definition at line 624 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h;
 
  h = GNUNET_new (struct GNUNET_PILS_Handle);
  h->cfg = cfg;
  h->pid_change_cb = pid_change_cb;
  h->pid_change_cb_cls = cls;
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  reconnect (h);
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_new, GNUNET_TIME_UNIT_ZERO, h, pid_change_cb(), and reconnect().

Referenced by advertise_dns_exit(), create_service(), DHTU_gnunet_init(), GCH_init(), GNUNET_PILS_create_key_ring(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GSC_KX_init(), main_init(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_disconnect()

void GNUNET_PILS_disconnect

(

struct GNUNET_PILS_Handle *

handle

)

Disconnect from the PILS service.

Parameters

handle

handle to the PILS service (was returned by GNUNET_PILS_connect)

Definition at line 647 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
 
  GNUNET_assert (NULL != handle);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Disonnecting from peer identity lifecycle service.\n");
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  if (NULL != handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  while (NULL != (op = handle->op_head))
    op_destroy (op);
  if (handle->peer_id)
    GNUNET_free (handle->peer_id);
  if (NULL != handle->private_key)
  {
    GNUNET_CRYPTO_zero_keys (handle->private_key,
                             sizeof (*handle->private_key));
    GNUNET_free (handle->private_key);
  }
  GNUNET_CRYPTO_zero_keys (handle->initial_key_material,
                           sizeof (handle->initial_key_material));
  GNUNET_free (handle);
}

References GNUNET_assert, GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), handle, LOG, GNUNET_VPN_Handle::mq, op, and op_destroy().

Referenced by cleaning_task(), cleanup(), cleanup_task(), destroy_service(), DHTU_gnunet_done(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), GCH_shutdown(), GNUNET_PILS_destroy_key_ring(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop(), GSC_KX_done(), run(), shutdown_task(), shutdown_task(), shutdown_task(), shutdown_task(), shutdown_task(), shutdown_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_sign_by_peer_identity()

struct GNUNET_PILS_Operation * GNUNET_PILS_sign_by_peer_identity	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_CRYPTO_SignaturePurpose *	purpose,
		GNUNET_PILS_SignResultCallback	cb,
		void *	cb_cls
	)

Sign data with the peer id.

Parameters

handle	handle to the PILS service
purpose	what to sign (size, purpose and data)
cb	callback to call once the signature is ready
cb_cls	closure to cb

Returns

handle to the operation, NULL on error

Definition at line 692 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
  struct SignRequestMessage *msg;
  size_t plen = ntohl (purpose->size);
 
  GNUNET_assert (sizeof (*msg) + plen <= UINT16_MAX);
  msg = GNUNET_malloc (sizeof (*msg) + plen);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST);
  msg->header.size = htons (sizeof (*msg) + plen);
  msg->rid = htonl (handle->op_id_counter++);
  memcpy (&msg[1], purpose, plen);
  op = op_start (handle, &msg->header);
  op->sign_cb = cb;
  op->cb_cls = cb_cls;
  op->op_id = ntohl (msg->rid);
  transmit_op (op);
  return op;
}

References GNUNET_assert, GNUNET_malloc, GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST, handle, msg, op, op_start(), GNUNET_MessageHeader::size, GNUNET_CRYPTO_SignaturePurpose::size, transmit_op(), and GNUNET_MessageHeader::type.

Referenced by do_dht_put(), GDS_helper_sign_path(), GNUNET_PILS_sign_hello(), regex_iterator(), send_create(), sign_message_by_peer(), and transmit_task_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_kem_decaps()

struct GNUNET_PILS_Operation * GNUNET_PILS_kem_decaps	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_CRYPTO_HpkeEncapsulation *	c,
		GNUNET_PILS_DecapsResultCallback	cb,
		void *	cb_cls
	)

Decaps an encapsulated key with our private key.

Parameters

handle	handle to the PILS service
c	the encapsulated key
prk	where to write the key material HKDF-Extract(c||aX)=HKDF-Extract(c||x(aG))

Returns

handle to the operation, NULL on error

Definition at line 728 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
  struct DecapsMessage *msg;
 
  msg = GNUNET_new (struct DecapsMessage);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS);
  msg->header.size = htons (sizeof (*msg));
  msg->c = *c;
  msg->rid = htonl (handle->op_id_counter++);
  op = op_start (handle, &msg->header);
  op->decaps_cb = cb;
  op->cb_cls = cb_cls;
  op->op_id = ntohl (msg->rid);
  transmit_op (op);
  return op;
}

References DecapsMessage::c, GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS, GNUNET_new, handle, msg, op, op_start(), GNUNET_MessageHeader::size, transmit_op(), and GNUNET_MessageHeader::type.

Here is the call graph for this function:

GNUNET_PILS_ecdh()

struct GNUNET_PILS_Operation * GNUNET_PILS_ecdh	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_CRYPTO_EcdhePublicKey *	pub,
		GNUNET_PILS_EcdhResultCallback	cb,
		void *	cb_cls
	)

Derive key material from a ECDH public key and our private key.

Parameters

handle	handle to the PILS service
pub	the public key
cb	the callback to call with the derived key material
cb_cls	callback closure

Returns

handle to the operation, NULL on error

Definition at line 751 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
  struct EcdhMessage *msg;
 
  GNUNET_assert ((handle) && (pub));
 
  msg = GNUNET_new (struct EcdhMessage);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_PILS_ECDH);
  msg->header.size = htons (sizeof (*msg));
  msg->pub = *pub;
  msg->rid = htonl (handle->op_id_counter++);
  op = op_start (handle, &msg->header);
  op->ecdh_cb = cb;
  op->cb_cls = cb_cls;
  op->op_id = ntohl (msg->rid);
  transmit_op (op);
  return op;
}

References GNUNET_assert, GNUNET_MESSAGE_TYPE_PILS_ECDH, GNUNET_new, handle, msg, op, op_start(), pub, GNUNET_MessageHeader::size, transmit_op(), and GNUNET_MessageHeader::type.

Referenced by GCT_handle_kx(), and GCT_handle_kx_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_cancel()

void GNUNET_PILS_cancel

(

struct GNUNET_PILS_Operation *

op

)

Cancel request.

Parameters

op	cancel PILS operation

Definition at line 776 of file pils_api.c.

{
  op_destroy (op);
}

References op, and op_destroy().

Referenced by cancel_address_store(), cleanup(), cleanup_helper_operation(), destroy_tunnel(), do_dht_put(), do_initial_dht_put(), do_shutdown(), GCC_destroy(), GCH_shutdown(), GCT_handle_kx(), GCT_handle_kx_auth(), iterate_cancel_signature(), regex_iterator(), send_create(), shutdown_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_derive_pid()

void GNUNET_PILS_derive_pid	(	size_t	seed_key_bytes,
		const uint8_t	seed_key[seed_key_bytes],
		const struct GNUNET_HashCode *	addrs_hash,
		struct GNUNET_CRYPTO_EddsaPrivateKey *	outkey
	)

Generate the peer id from the addresses hash and the initial secret key.

Parameters

	seed_key_bytes	length of the seed key in bytes
	seed_key	the initial secret key
	addrs_hash	the address to use for derivation
[out]	outkey	the (private) peer identity key

Since we should have initial keying material of good quality here, this is effectively a PRF called on the address hash with a uniform random key.

We now expand the PRK to the key size we actually require. FIXME: IF we want to use elligator, we need to find a private key that can actually be used as such. For that, we may want to add a counter to the initial secret key to the above PRF.

Definition at line 783 of file pils_api.c.

{
  struct GNUNET_ShortHashCode prk;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_hkdf_extract (&prk,
                                             addrs_hash,
                                             sizeof *addrs_hash,
                                             seed_key,
                                             seed_key_bytes));
  GNUNET_CRYPTO_hkdf_expand (
    outkey,
    sizeof *outkey,
    &prk,
    GNUNET_CRYPTO_kdf_arg_string ("gnunet-pils-ephemeral-peer-key"));
}

References GNUNET_assert, GNUNET_CRYPTO_hkdf_expand, GNUNET_CRYPTO_hkdf_extract(), GNUNET_CRYPTO_kdf_arg_string, GNUNET_OK, and seed_key.

Referenced by derive_private_key(), do_generate_pid(), pid_change_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_feed_addresses()

void GNUNET_PILS_feed_addresses	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_HELLO_Builder *	addresses_builder
	)

Feed a set of addresses to pils so that it will generate a new peer id based on the given set of addresses.

THIS IS ONLY TO BE CALLED FROM CORE!

The address representation will be canonicalized/sorted by pils before the new peer id is generated.

Parameters

handle	the handle to the PILS service
addresses_builder	addresses to feed as builder

Definition at line 817 of file pils_api.c.

{
  struct FeedAddressesMessage *msg;
  struct GNUNET_MQ_Envelope *env;
  size_t block_bytes;
 
  block_bytes = GNUNET_HELLO_get_builder_to_block_size (builder);
  // TODO check whether the new hash and the 'current' hash are the same -
  //      nothing to do in that case (directly return the peer id?)
  env = GNUNET_MQ_msg_extra (msg,
                             block_bytes,
                             GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES);
  msg->block_len = htonl (block_bytes);
  GNUNET_HELLO_builder_to_block (
    builder,
    NULL,
    NULL,
    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_ZERO),
    (char*) &msg[1]);
  GNUNET_MQ_send (handle->mq, env);
}

References builder, env, GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO, handle, GNUNET_VPN_Handle::mq, and msg.

Referenced by feed_addresses_to_pils().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_sign_hello()

struct GNUNET_PILS_Operation * GNUNET_PILS_sign_hello	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_HELLO_Builder *	builder,
		struct GNUNET_TIME_Absolute	et,
		GNUNET_PILS_SignResultCallback	cb,
		void *	cb_cls
	)

Create HELLO signature.

Parameters

handle	handle to the pils service
builder	the builder to use
et	expiration time to sign
cb	callback to call with the signature
cb_cls	closure to cb

Definition at line 851 of file pils_api.c.

{
  struct PilsHelloSignaturePurpose hsp = {
    .purpose.size = htonl (sizeof (hsp)),
    .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_HELLO),
    .expiration_time = GNUNET_TIME_absolute_hton (et)
  };
  GNUNET_HELLO_builder_hash_addresses (builder,
                                       &hsp.h_addrs);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Address hash is %s\n",
              GNUNET_h2s_full (&hsp.h_addrs));
  return GNUNET_PILS_sign_by_peer_identity (handle,
                                            &hsp.purpose,
                                            cb,
                                            cb_cls);
}

References builder, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s_full(), GNUNET_HELLO_builder_hash_addresses(), GNUNET_log, GNUNET_PILS_sign_by_peer_identity(), GNUNET_SIGNATURE_PURPOSE_HELLO, GNUNET_TIME_absolute_hton(), PilsHelloSignaturePurpose::h_addrs, handle, PilsHelloSignaturePurpose::purpose, and GNUNET_CRYPTO_SignaturePurpose::size.

Referenced by peerstore_store_own_cb(), and pid_changed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_get_identity()

const struct GNUNET_PeerIdentity * GNUNET_PILS_get_identity

(

const struct GNUNET_PILS_Handle *

handle

)

Return the current peer identity of a given handle.

Parameters

handle

handle to the pils service

Returns

Peer identity or NULL on failure

Definition at line 875 of file pils_api.c.

{
  GNUNET_assert (handle);
 
  return handle->peer_id;
}

References GNUNET_assert, and handle.

Referenced by announce_id(), cb_path_signed(), check_dv_box(), check_dv_learn(), decaps_dv_box_cont(), decrypt_and_check_tc(), dir_ready_cb(), do_initial_dht_put(), do_rekey(), encapsulate_for_dv(), find_proof(), forward_dv_learn(), forward_reply(), GCCH_bind(), GCCH_channel_local_new(), GCPP_try_path_from_dht(), GCT_alice_or_betty(), GDS_CLIENTS_handle_reply(), GDS_NEIGHBOURS_get_id(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GDS_try_connect(), GDS_u_connect(), get_next_free_ctn(), got_hello(), GSC_CLIENTS_solicit_request(), GSC_complete_initialization_cb(), GSC_KX_start(), GSC_SESSIONS_dequeue_request(), GSF_peer_connect_handler(), handle_backchannel_encapsulation(), handle_client_init(), handle_client_send_request(), handle_communicator_available(), handle_connection_create(), handle_core_connect(), handle_core_disconnect(), handle_dht_local_get(), handle_dht_local_hello_get(), handle_dht_local_put(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_dv_box(), handle_dv_learn(), handle_find_my_hello(), handle_hello_for_client(), handle_hello_for_incoming(), handle_p2p_estimate(), handle_port_open(), handle_suggest(), handle_transport_notify_connect(), handshake_monotime_cb(), iface_proc(), inject_rekey(), learn_dv_path(), mq_send(), peerinfo_cb(), pid_change_cb(), pid_change_cb(), pils_id_change_cb(), pils_pid_change_cb(), pils_sign_address(), recv_rx_key_cb(), regex_iterator(), route_message(), run(), send_broken_without_mqm(), send_challenge(), send_create(), send_initiator_hello(), send_msg_with_kx(), setup_flood_message(), setup_in_cipher(), setup_in_cipher_elligator(), sock_read(), sock_read(), start_dv_learn(), store_pi(), tokenized_cb(), transmit_kx(), try_connection_reversal(), try_handle_plaintext(), update_flood_message(), and verify_confirmation().

GNUNET_PILS_get_identity_hash()

const struct GNUNET_HashCode * GNUNET_PILS_get_identity_hash

(

const struct GNUNET_PILS_Handle *

handle

)

Return the hash of the current peer identity from a given handle.

Parameters

handle

handle to the pils service

Returns

Peer identity hash or NULL on failure

Definition at line 884 of file pils_api.c.

{
  GNUNET_assert (handle);
 
  if (NULL == handle->peer_id)
    return NULL;
 
  return &handle->peer_hash;
}

References GNUNET_assert, and handle.

Referenced by find_bucket(), GDS_am_closest_peer(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), handle_find_my_hello(), handle_initiator_hello(), handle_initiator_hello_cont(), restart_kx(), select_peer(), and send_find_peer_message().

Here is the caller graph for this function:

GNUNET_PILS_enable_private_key()

enum GNUNET_GenericReturnValue GNUNET_PILS_enable_private_key

(

struct GNUNET_PILS_Handle *

handle

)

Enable local access to the private key of the current peer identity.

Loads the peer's master key from [PEER]/PRIVATE_KEY (the same file the PILS service itself uses) and derives the private key belonging to the current peer identity from it, re-deriving it whenever the peer identity changes. This lets a caller sign directly with GNUNET_CRYPTO_eddsa_sign() instead of round-tripping through the service with GNUNET_PILS_sign_by_peer_identity(), which is what you want when the signature is needed in the middle of a synchronous operation.

Only call this from components that may hold the peer's private key.

Parameters

handle

handle to the pils service

Returns

GNUNET_OK on success, GNUNET_SYSERR if the key could not be loaded (the handle stays usable, just without local key access)

Definition at line 896 of file pils_api.c.

{
  char *keyfile;
  struct GNUNET_CRYPTO_EddsaPrivateKey key;
 
  GNUNET_assert (handle);
  if (handle->have_ikm)
    return GNUNET_OK; /* already enabled */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (handle->cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "PEER",
                               "PRIVATE_KEY");
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &key))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to load the peer's private key from `%s'\n",
         keyfile);
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
  GNUNET_free (keyfile);
  GNUNET_assert (sizeof (handle->initial_key_material) == sizeof (key.d));
  memcpy (handle->initial_key_material,
          key.d,
          sizeof (handle->initial_key_material));
  GNUNET_CRYPTO_zero_keys (&key,
                           sizeof (key));
  handle->have_ikm = true;
  /* If the service already told us our identity, catch up now so that
     callers do not have to wait for the next PID change. */
  if (NULL != handle->peer_id)
    derive_private_key (handle);
  return GNUNET_OK;
}

References GNUNET_VPN_Handle::cfg, derive_private_key(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, handle, key, and LOG.

Referenced by GSC_KX_start(), run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_get_private_key()

const struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_PILS_get_private_key

(

const struct GNUNET_PILS_Handle *

handle

)

Return the private key of the current peer identity.

Requires a preceding successful call to GNUNET_PILS_enable_private_key(). The returned key belongs to the identity GNUNET_PILS_get_identity() reports and stays valid until the peer identity changes, so do not cache it across GNUNET_PILS_PidChangeCallback invocations.

Parameters

handle

handle to the pils service

Returns

the private key, or NULL if local key access was not enabled, no peer identity is known yet, or the loaded key does not match the identity announced by the service

Definition at line 943 of file pils_api.c.

{
  GNUNET_assert (handle);
 
  return handle->private_key;
}

References GNUNET_assert, and handle.

Referenced by GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), handle_dv_box(), handle_initiator_hello(), handle_responder_hello(), and sign_by_my_identity().

Here is the caller graph for this function:

pid_change_cb()

void pid_change_cb	(	void *	cls,
		const struct GNUNET_HELLO_Parser *	parser,
		const struct GNUNET_HashCode *	addr_hash
	)

Definition at line 952 of file pils_api.c.

{
  struct GNUNET_PILS_KeyRing *key_ring;
  enum GNUNET_GenericReturnValue initialized;
 
  GNUNET_assert ((cls) && (addr_hash));
 
  key_ring = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got PID to derive from `%s':\n",
              GNUNET_h2s (addr_hash));
  if (NULL == key_ring->private_key)
  {
    key_ring->private_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
    initialized = GNUNET_YES;
  }
  else
    initialized = GNUNET_NO;
 
  GNUNET_PILS_derive_pid (sizeof (key_ring->initial_key_material),
                          key_ring->initial_key_material,
                          addr_hash,
                          key_ring->private_key);
  GNUNET_CRYPTO_eddsa_key_get_public (key_ring->private_key,
                                      &(key_ring->identity.public_key));
  GNUNET_CRYPTO_hash (&(key_ring->identity),
                      sizeof (key_ring->identity),
                      &(key_ring->hash));
 
 
  GNUNET_assert (0 == GNUNET_memcmp (GNUNET_PILS_get_identity (key_ring->pils),
                                     &(key_ring->identity)));
 
  if (GNUNET_YES != initialized)
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialize key ring\n");
 
  if (key_ring->init_cb)
    key_ring->init_cb (key_ring->cls);
}

References GNUNET_PILS_KeyRing::cls, GNUNET_assert, GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_new, GNUNET_NO, GNUNET_PILS_derive_pid(), GNUNET_PILS_get_identity(), GNUNET_YES, GNUNET_PILS_KeyRing::hash, GNUNET_PILS_KeyRing::identity, GNUNET_PILS_KeyRing::init_cb, GNUNET_PILS_KeyRing::initial_key_material, initialized, key_ring, GNUNET_PILS_KeyRing::pils, GNUNET_PILS_KeyRing::private_key, and GNUNET_PeerIdentity::public_key.

Referenced by GNUNET_PILS_connect(), and GNUNET_PILS_create_key_ring().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_create_key_ring()

struct GNUNET_PILS_KeyRing * GNUNET_PILS_create_key_ring	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_SCHEDULER_TaskCallback	init_cb,
		void *	cls
	)

Get the initial secret key for generating the peer id.

Create a key ring handle to use the current peer identity key.

This is supposed to be generated at random once in the lifetime of a peer, so all generated peer ids use the same initial secret key to obtain the same peer id per set of addresses.

First check whether there's already a initial secret key. If so: return it. If no initial secret key exists yet, generate at random and store it where it will be found.

Definition at line 1008 of file pils_api.c.

{
  char *keyfile;
  struct GNUNET_CRYPTO_EddsaPrivateKey key;
 
  GNUNET_assert (cfg);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Create key ring!\n");
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "PEER",
                               "PRIVATE_KEY");
    return NULL;
  }
 
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_free (keyfile);
    return NULL;
  }
 
  GNUNET_free (keyfile);
 
  struct GNUNET_PILS_KeyRing *key_ring =
    GNUNET_new (struct GNUNET_PILS_KeyRing);
  if (NULL == key_ring)
    return NULL;
  key_ring->init_cb = init_cb;
  key_ring->cls = cls;
 
  GNUNET_assert (sizeof (key_ring->initial_key_material) == sizeof key.d);
 
  key_ring->pils = GNUNET_PILS_connect (cfg, &pid_change_cb, key_ring);
  if (NULL == key_ring->pils)
  {
    GNUNET_free (key_ring);
    return NULL;
  }
 
  memcpy (key_ring->initial_key_material, key.d,
          sizeof (key_ring->initial_key_material));
 
  return key_ring;
}

References cfg, GNUNET_PILS_KeyRing::cls, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SYSERR, GNUNET_YES, init_cb(), GNUNET_PILS_KeyRing::init_cb, GNUNET_PILS_KeyRing::initial_key_material, key, key_ring, LOG, pid_change_cb(), and GNUNET_PILS_KeyRing::pils.

Referenced by run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_destroy_key_ring()

void GNUNET_PILS_destroy_key_ring

(

struct GNUNET_PILS_KeyRing *

key_ring

)

Destroy a key ring handle and free its memory.

Parameters

key_ring

key ring handle

Definition at line 1068 of file pils_api.c.

{
  GNUNET_assert (key_ring);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroy key ring!\n");
 
  if (key_ring->pils)
    GNUNET_PILS_disconnect (key_ring->pils);
 
  if (key_ring->private_key)
  {
    GNUNET_CRYPTO_zero_keys (key_ring->private_key,
                             sizeof (*(key_ring->private_key)));
    GNUNET_free (key_ring->private_key);
  }
 
  GNUNET_CRYPTO_zero_keys (key_ring->initial_key_material,
                           sizeof (key_ring->initial_key_material));
  GNUNET_free (key_ring);
}

References GNUNET_assert, GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_PILS_disconnect(), GNUNET_PILS_KeyRing::initial_key_material, key_ring, LOG, GNUNET_PILS_KeyRing::pils, and GNUNET_PILS_KeyRing::private_key.

Referenced by do_shutdown(), and do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_key_ring_get_private_key()

const struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_PILS_key_ring_get_private_key

(

const struct GNUNET_PILS_KeyRing *

key_ring

)

Return the current private key of a given key ring handle.

Parameters

key_ring

key ring handle

Returns

Private key or NULL on failure

Definition at line 1091 of file pils_api.c.

{
  GNUNET_assert (key_ring);
 
  return key_ring->private_key;
}

References GNUNET_assert, key_ring, and GNUNET_PILS_KeyRing::private_key.

Referenced by iface_proc(), inject_rekey(), send_challenge(), send_msg_with_kx(), setup_in_cipher(), setup_in_cipher_elligator(), setup_initial_shared_secret_dec(), setup_shared_secret_dec(), and transmit_kx().

Here is the caller graph for this function: