gnunet-service-core_kx.h File Reference

code for managing the key exchange (SET_KEY, PING, PONG) with other peers More...

#include "gnunet_util_lib.h"

Include dependency graph for gnunet-service-core_kx.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	GSC_KX_encrypt_and_transmit (struct GSC_KeyExchangeInfo *kx, const void *payload, size_t payload_size)
	Encrypt and transmit a message with the given payload. More...
int	GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
	Initialize KX subsystem. More...
void	GSC_KX_done (void)
	Shutdown KX subsystem. More...
int	GSC_NEIGHBOURS_check_excess_bandwidth (const struct GSC_KeyExchangeInfo *target)
	Check if the given neighbour has excess bandwidth available. More...
unsigned int	GSC_NEIGHBOURS_get_queue_length (const struct GSC_KeyExchangeInfo *target)
	Check how many messages are queued for the given neighbour. More...
void	GSC_KX_handle_client_monitor_peers (struct GNUNET_MQ_Handle *mq)
	Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request. More...

Detailed Description

code for managing the key exchange (SET_KEY, PING, PONG) with other peers

Author

Christian Grothoff

Definition in file gnunet-service-core_kx.h.

Function Documentation

GSC_KX_encrypt_and_transmit()

void GSC_KX_encrypt_and_transmit	(	struct GSC_KeyExchangeInfo *	kx,
		const void *	payload,
		size_t	payload_size
	)

Encrypt and transmit a message with the given payload.

Parameters

kx	key exchange context
payload	payload of the message
payload_size	number of bytes in 'payload'

Definition at line 1630 of file gnunet-service-core_kx.c.

{
  size_t used = payload_size + sizeof(struct EncryptedMessage);
  char pbuf[used]; /* plaintext */
  struct EncryptedMessage *em; /* encrypted message */
  struct EncryptedMessage *ph; /* plaintext header */
  struct GNUNET_MQ_Envelope *env;
#if CONG_CRYPTO_ENABLED
#else
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  struct GNUNET_CRYPTO_AuthKey auth_key;
#endif
 
  ph = (struct EncryptedMessage *) pbuf;
  ph->sequence_number = htonl (++kx->last_sequence_number_sent);
  ph->reserved = 0;
  ph->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
  GNUNET_memcpy (&ph[1], payload, payload_size);
  env = GNUNET_MQ_msg_extra (em,
                             payload_size,
                             GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE);
#if CONG_CRYPTO_ENABLED
  randombytes_buf (ph->nonce, sizeof (ph->nonce));
  GNUNET_memcpy (em->nonce, ph->nonce, sizeof (ph->nonce));
  GNUNET_assert (0 ==
                 crypto_aead_xchacha20poly1305_ietf_encrypt_detached (
                   (unsigned char*) &em->sequence_number,
                   em->tag,
                   NULL,
                   (unsigned char*) &ph->sequence_number,
                   used - ENCRYPTED_HEADER_SIZE,
                   NULL, 0,
                   NULL,
                   ph->nonce,
                   kx->encrypt_key));
#else
  ph->iv_seed = calculate_seed (kx);
  em->iv_seed = ph->iv_seed;
  derive_iv (&iv, &kx->encrypt_key, ph->iv_seed, kx->peer);
  GNUNET_assert (GNUNET_OK == do_encrypt (kx,
                                          &iv,
                                          &ph->sequence_number,
                                          &em->sequence_number,
                                          used - ENCRYPTED_HEADER_SIZE));
#if DEBUG_KX
  {
    struct GNUNET_HashCode hc;
 
    GNUNET_CRYPTO_hash (&ph->sequence_number,
                        used - ENCRYPTED_HEADER_SIZE,
                        &hc);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Encrypted payload `%s' of %u bytes for %s\n",
                GNUNET_h2s (&hc),
                (unsigned int) (used - ENCRYPTED_HEADER_SIZE),
                GNUNET_i2s (kx->peer));
  }
#endif
  derive_auth_key (&auth_key, &kx->encrypt_key, ph->iv_seed);
  GNUNET_CRYPTO_hmac (&auth_key,
                      &em->sequence_number,
                      used - ENCRYPTED_HEADER_SIZE,
                      &em->hmac);
#if DEBUG_KX
  {
    struct GNUNET_HashCode hc;
 
    GNUNET_CRYPTO_hash (&auth_key, sizeof(auth_key), &hc);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "For peer %s, used AC %s to create hmac %s\n",
                GNUNET_i2s (kx->peer),
                GNUNET_h2s (&hc),
                GNUNET_h2s2 (&em->hmac));
  }
#endif
#endif
  kx->has_excess_bandwidth = GNUNET_NO;
  GNUNET_MQ_send (kx->mq, env);
}

References calculate_seed(), derive_auth_key(), derive_iv(), do_encrypt(), GSC_KeyExchangeInfo::encrypt_key, ENCRYPTED_HEADER_SIZE, env, GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hmac(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s2(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GSC_KeyExchangeInfo::has_excess_bandwidth, EncryptedMessage::hmac, EncryptedMessage::iv_seed, GSC_KeyExchangeInfo::last_sequence_number_sent, GSC_KeyExchangeInfo::mq, payload, GSC_KeyExchangeInfo::peer, EncryptedMessage::reserved, EncryptedMessage::sequence_number, and EncryptedMessage::timestamp.

Referenced by transmit_typemap_task(), and try_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_KX_init()

int GSC_KX_init

(

struct GNUNET_CRYPTO_EddsaPrivateKey *

pk

)

Initialize KX subsystem.

Parameters

pk	private key to use for the peer

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2051 of file gnunet-service-core_kx.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (ephemeral_key,
                             GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY,
                             struct EphemeralKeyMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (ping,
                             GNUNET_MESSAGE_TYPE_CORE_PING,
                             struct PingMessage,
                             NULL),
    GNUNET_MQ_hd_fixed_size (pong,
                             GNUNET_MESSAGE_TYPE_CORE_PONG,
                             struct PongMessage,
                             NULL),
    GNUNET_MQ_hd_var_size (encrypted,
                           GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE,
                           struct EncryptedMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
 
  my_private_key = *pk;
  GNUNET_CRYPTO_eddsa_key_get_public (&my_private_key,
                                      &GSC_my_identity.public_key);
  GNUNET_CRYPTO_ecdhe_key_create (&my_ephemeral_key);
  sign_ephemeral_key ();
  {
    struct GNUNET_HashCode eh;
 
    GNUNET_CRYPTO_hash (&current_ekm.ephemeral_key,
                        sizeof(current_ekm.ephemeral_key),
                        &eh);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Starting with ephemeral key %s\n",
                GNUNET_h2s (&eh));
  }
 
  nc = GNUNET_notification_context_create (1);
  rekey_task = GNUNET_SCHEDULER_add_delayed (REKEY_FREQUENCY, &do_rekey, NULL);
  transport =
    GNUNET_TRANSPORT_core_connect (GSC_cfg,
                                   &GSC_my_identity,
                                   handlers,
                                   NULL,
                                   &handle_transport_notify_connect,
                                   &handle_transport_notify_disconnect);
  if (NULL == transport)
  {
    GSC_KX_done ();
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References current_ekm, do_rekey(), EphemeralKeyMessage::ephemeral_key, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY, GNUNET_MESSAGE_TYPE_CORE_PING, GNUNET_MESSAGE_TYPE_CORE_PONG, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_notification_context_create(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TRANSPORT_core_connect(), GSC_cfg, GSC_KX_done(), GSC_my_identity, handle_transport_notify_connect(), handle_transport_notify_disconnect(), handlers, my_ephemeral_key, my_private_key, nc, pk, GNUNET_PeerIdentity::public_key, REKEY_FREQUENCY, rekey_task, sign_ephemeral_key(), and transport.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_KX_done()

void GSC_KX_done

(

void

)

Shutdown KX subsystem.

Definition at line 2111 of file gnunet-service-core_kx.c.

{
  if (NULL != transport)
  {
    GNUNET_TRANSPORT_core_disconnect (transport);
    transport = NULL;
  }
  if (NULL != rekey_task)
  {
    GNUNET_SCHEDULER_cancel (rekey_task);
    rekey_task = NULL;
  }
  memset (&my_ephemeral_key,
          0,
          sizeof (my_ephemeral_key));
  memset (&my_private_key,
          0,
          sizeof (my_private_key));
  if (NULL != nc)
  {
    GNUNET_notification_context_destroy (nc);
    nc = NULL;
  }
}

References GNUNET_notification_context_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_core_disconnect(), my_ephemeral_key, my_private_key, nc, rekey_task, and transport.

Referenced by GSC_KX_init(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_NEIGHBOURS_check_excess_bandwidth()

int GSC_NEIGHBOURS_check_excess_bandwidth

(

const struct GSC_KeyExchangeInfo *

target

)

Check if the given neighbour has excess bandwidth available.

Parameters

target

neighbour to check

Returns

GNUNET_YES if excess bandwidth is available, GNUNET_NO if not

Definition at line 2151 of file gnunet-service-core_kx.c.

{
  return kxinfo->has_excess_bandwidth;
}

References GSC_KeyExchangeInfo::has_excess_bandwidth.

Referenced by try_transmission().

Here is the caller graph for this function:

GSC_NEIGHBOURS_get_queue_length()

unsigned int GSC_NEIGHBOURS_get_queue_length

(

const struct GSC_KeyExchangeInfo *

kxinfo

)

Check how many messages are queued for the given neighbour.

Parameters

target

neighbour to check

Returns

number of items in the message queue

Parameters

kxinfo

data about neighbour to check

Returns

number of items in the message queue

Definition at line 2144 of file gnunet-service-core_kx.c.

{
  return GNUNET_MQ_get_length (kxinfo->mq);
}

References GNUNET_MQ_get_length(), and GSC_KeyExchangeInfo::mq.

Referenced by try_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_KX_handle_client_monitor_peers()

void GSC_KX_handle_client_monitor_peers

(

struct GNUNET_MQ_Handle *

mq

)

Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.

For this request type, the client does not have to have transmitted an INIT request. All current peers are returned, regardless of which message types they accept.

Parameters

mq	message queue to add for monitoring

Definition at line 2166 of file gnunet-service-core_kx.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct MonitorNotifyMessage *done_msg;
  struct GSC_KeyExchangeInfo *kx;
 
  GNUNET_notification_context_add (nc, mq);
  for (kx = kx_head; NULL != kx; kx = kx->next)
  {
    struct GNUNET_MQ_Envelope *env_notify;
    struct MonitorNotifyMessage *msg;
 
    env_notify = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY);
    msg->state = htonl ((uint32_t) kx->status);
    msg->peer = *kx->peer;
    msg->timeout = GNUNET_TIME_absolute_hton (kx->timeout);
    GNUNET_MQ_send (mq, env_notify);
  }
  env = GNUNET_MQ_msg (done_msg, GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY);
  done_msg->state = htonl ((uint32_t) GNUNET_CORE_KX_ITERATION_FINISHED);
  done_msg->timeout = GNUNET_TIME_absolute_hton (GNUNET_TIME_UNIT_FOREVER_ABS);
  GNUNET_MQ_send (mq, env);
}

References env, GNUNET_CORE_KX_ITERATION_FINISHED, GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_FOREVER_ABS, kx_head, mq, msg, nc, GSC_KeyExchangeInfo::next, GSC_KeyExchangeInfo::peer, MonitorNotifyMessage::state, GSC_KeyExchangeInfo::status, MonitorNotifyMessage::timeout, and GSC_KeyExchangeInfo::timeout.

Referenced by handle_client_monitor_peers().

Here is the call graph for this function:

Here is the caller graph for this function: