messenger_api_handle.c File Reference

#include "messenger_api_handle.h"
#include "gnu_name_system_record_types.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_util_lib.h"
#include "messenger_api_epoch.h"
#include "messenger_api_epoch_announcement.h"
#include "messenger_api_epoch_group.h"
#include "messenger_api_room.h"
#include "messenger_api_util.h"
#include <ctype.h>

Include dependency graph for messenger_api_handle.c:

Go to the source code of this file.

Functions
struct GNUNET_MESSENGER_Handle *	create_handle (const struct GNUNET_CONFIGURATION_Handle *config, const struct GNUNET_HashCode *secret, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
	Creates and allocates a new handle using a given configuration, a secret and a custom message callback with a given closure for the client API.
static enum GNUNET_GenericReturnValue	iterate_destroy_room (void *cls, const struct GNUNET_HashCode *key, void *value)
void	destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
	Destroys a handle and frees its memory fully from the client API.
void	set_handle_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
	Sets the name of a handle to a specific name.
const char *	get_handle_name (const struct GNUNET_MESSENGER_Handle *handle)
	Returns the current name of a given handle or NULL if no valid name was assigned yet.
static void	cb_key_error (void *cls)
static void	read_handle_epoch_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const struct GNUNET_MESSENGER_RoomEpochKeyRecord *record)
static void	read_handle_encryption_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const struct GNUNET_MESSENGER_EncryptionKeyRecord *record)
static void	cb_key_monitor (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
static enum GNUNET_GenericReturnValue	it_announcement_store_key (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static enum GNUNET_GenericReturnValue	it_group_store_key (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static enum GNUNET_GenericReturnValue	it_epoch_store_keys (void *cls, const struct GNUNET_HashCode *key, void *value)
static enum GNUNET_GenericReturnValue	it_room_store_keys (void *cls, const struct GNUNET_HashCode *key, void *value)
static void	cb_key_sync (void *cls)
void	set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *key)
	Sets the keypair of a given handle to the keypair of a specific private key.
const struct GNUNET_CRYPTO_BlindablePrivateKey *	get_handle_key (const struct GNUNET_MESSENGER_Handle *handle)
	Returns the private key of a given handle.
const struct GNUNET_CRYPTO_BlindablePublicKey *	get_handle_pubkey (const struct GNUNET_MESSENGER_Handle *handle)
	Returns the public key of a given handle.
struct GNUNET_MESSENGER_ContactStore *	get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle)
	Returns the used contact store of a given handle.
struct GNUNET_MESSENGER_Contact *	get_handle_contact (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
	Returns the contact of a given handle in a room identified by a given key.
void	open_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
	Marks a room known to a handle identified by a given key as open.
void	entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
	Adds a tunnel for a room known to a handle identified by a given key to a list of opened connections.
void	close_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
	Destroys and so implicitly closes a room known to a handle identified by a given key.
struct GNUNET_MESSENGER_Room *	get_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key, enum GNUNET_GenericReturnValue init)
	Returns the room known to a handle identified by a given key.
enum GNUNET_GenericReturnValue	store_handle_epoch_key (const struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_HashCode *hash, const struct GNUNET_ShortHashCode *identifier, const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key, uint32_t flags, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls, struct GNUNET_NAMESTORE_QueueEntry **query)
	Stores/deletes a shared_key for a given room from a handle identified by its key in an epoch with certain hash using a specific identifier for this epoch key.
enum GNUNET_GenericReturnValue	store_handle_encryption_key (const struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_CRYPTO_HpkePrivateKey *encryption_key, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls, struct GNUNET_NAMESTORE_QueueEntry **query)
	Stores an encryption_key for a given room from a handle identified by its key/i>.

Function Documentation

create_handle()

struct GNUNET_MESSENGER_Handle * create_handle	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_HashCode *	secret,
		GNUNET_MESSENGER_MessageCallback	msg_callback,
		void *	msg_cls
	)

Creates and allocates a new handle using a given configuration, a secret and a custom message callback with a given closure for the client API.

Parameters

[in]	cfg	Configuration
[in]	secret	Storage secret
[in]	msg_callback	Message callback
[in,out]	msg_cls	Closure

Returns

New handle

Definition at line 40 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
 
  GNUNET_assert (config);
 
  handle = GNUNET_new (struct GNUNET_MESSENGER_Handle);
 
  handle->config = config;
  handle->mq = NULL;
 
  handle->group_keys = GNUNET_CONFIGURATION_get_value_yesno (
    handle->config,
    GNUNET_MESSENGER_SERVICE_NAME,
    "MESSENGER_GROUP_KEYS");
 
  if (handle->config)
    handle->namestore = GNUNET_NAMESTORE_connect (handle->config);
 
  if (secret)
    GNUNET_memcpy (&(handle->secret), secret, sizeof (handle->secret));
  else
    memset (&(handle->secret), 0, sizeof (handle->secret));
 
  handle->msg_callback = msg_callback;
  handle->msg_cls = msg_cls;
 
  handle->name = NULL;
  handle->key = NULL;
  handle->pubkey = NULL;
 
  handle->reconnect_time = GNUNET_TIME_relative_get_zero_ ();
  handle->reconnect_task = NULL;
 
  handle->key_monitor = NULL;
 
  handle->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  init_contact_store (get_handle_contact_store (handle));
 
  return handle;
}

References config, get_handle_contact_store(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_memcpy, GNUNET_MESSENGER_SERVICE_NAME, GNUNET_NAMESTORE_connect(), GNUNET_new, GNUNET_NO, GNUNET_TIME_relative_get_zero_(), handle, init_contact_store(), GNUNET_VPN_Handle::mq, GNUNET_MESSENGER_Handle::msg_callback, GNUNET_MESSENGER_Handle::msg_cls, and GNUNET_MESSENGER_Handle::secret.

Referenced by GNUNET_MESSENGER_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_destroy_room()

static enum GNUNET_GenericReturnValue iterate_destroy_room ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Definition at line 88 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert (value);
 
  room = value;
 
  destroy_room (room);
  return GNUNET_YES;
}

References destroy_room(), GNUNET_assert, GNUNET_YES, and value.

Referenced by destroy_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_handle()

void destroy_handle

(

struct GNUNET_MESSENGER_Handle *

handle

)

Destroys a handle and frees its memory fully from the client API.

Parameters

[in,out]

handle

Handle

Definition at line 104 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  clear_contact_store (get_handle_contact_store (handle));
 
  if (handle->rooms)
  {
    GNUNET_CONTAINER_multihashmap_iterate (
      handle->rooms, iterate_destroy_room, NULL);
 
    GNUNET_CONTAINER_multihashmap_destroy (handle->rooms);
  }
 
  if (handle->key_monitor)
    GNUNET_NAMESTORE_zone_monitor_stop (handle->key_monitor);
 
  if (handle->reconnect_task)
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
 
  if (handle->mq)
    GNUNET_MQ_destroy (handle->mq);
 
  if (handle->namestore)
    GNUNET_NAMESTORE_disconnect (handle->namestore);
 
  if (handle->name)
    GNUNET_free (handle->name);
 
  if (handle->key)
    GNUNET_free (handle->key);
 
  if (handle->pubkey)
    GNUNET_free (handle->pubkey);
 
  GNUNET_free (handle);
}

References clear_contact_store(), get_handle_contact_store(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_SCHEDULER_cancel(), handle, iterate_destroy_room(), and GNUNET_VPN_Handle::mq.

Referenced by GNUNET_MESSENGER_connect(), and GNUNET_MESSENGER_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

set_handle_name()

void set_handle_name	(	struct GNUNET_MESSENGER_Handle *	handle,
		const char *	name
	)

Sets the name of a handle to a specific name.

Parameters

[in,out]	handle	Handle
[in]	name	New name

Definition at line 144 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  if (handle->name)
    GNUNET_free (handle->name);
 
  handle->name = name ? GNUNET_strdup (name) : NULL;
}

References GNUNET_assert, GNUNET_free, GNUNET_strdup, handle, and name.

Referenced by GNUNET_MESSENGER_connect(), and GNUNET_MESSENGER_set_name().

Here is the caller graph for this function:

get_handle_name()

const char * get_handle_name

(

const struct GNUNET_MESSENGER_Handle *

handle

)

Returns the current name of a given handle or NULL if no valid name was assigned yet.

Parameters

[in]

handle

Handle

Returns

Name of the handle or NULL

Definition at line 157 of file messenger_api_handle.c.

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

References GNUNET_assert, and handle.

Referenced by cb_key_error(), cb_key_sync(), GNUNET_MESSENGER_get_name(), handle_name_message(), iterate_send_name_to_room(), and send_message_to_room_with_key().

Here is the caller graph for this function:

cb_key_error()

static void cb_key_error ( void *  cls )

static

Definition at line 166 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
  const char *name;
 
  GNUNET_assert (cls);
 
  handle = cls;
  name = get_handle_name (handle);
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on monitoring records: %s\n",
              name);
}

References get_handle_name(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, handle, and name.

Referenced by set_handle_key().

Here is the call graph for this function:

Here is the caller graph for this function:

read_handle_epoch_key()

static void read_handle_epoch_key ( struct GNUNET_MESSENGER_Handle *  handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const struct GNUNET_MESSENGER_RoomEpochKeyRecord *  record  )

static

Definition at line 182 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
  struct GNUNET_MESSENGER_Epoch *epoch;
  union GNUNET_MESSENGER_EpochIdentifier identifier;
  enum GNUNET_GenericReturnValue valid;
  struct GNUNET_CRYPTO_SymmetricSessionKey shared_key;
 
  GNUNET_assert ((handle) && (zone) && (record));
 
  room = get_handle_room (handle, &(record->key), GNUNET_YES);
 
  if (! room)
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Monitor epoch key record of room: %s\n",
              GNUNET_h2s (get_room_key (room)));
 
  epoch = get_room_epoch (room, &(record->hash), GNUNET_NO);
 
  if (! epoch)
    return;
 
  GNUNET_memcpy (
    &identifier,
    &(record->identifier),
    sizeof (record->identifier));
  valid = (GNUNET_MESSENGER_FLAG_EPOCH_VALID & record->flags? GNUNET_YES :
           GNUNET_NO);
 
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey skey;
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
    int32_t checksum;
 
    if (GNUNET_YES != GNUNET_CRYPTO_kdf (&skey, sizeof (skey),
                                         get_room_key (room),
                                         sizeof (room->key),
                                         &(handle->secret),
                                         sizeof (handle->secret),
                                         zone,
                                         sizeof (*zone),
                                         &(epoch->hash),
                                         sizeof (epoch->hash),
                                         &(identifier.hash),
                                         sizeof (identifier.hash),
                                         NULL))
      return;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      get_room_key (room), sizeof (room->key),
      &(epoch->hash), sizeof (epoch->hash),
      &(identifier.hash), sizeof (identifier.hash),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_decrypt (&(record->shared_key),
                                               sizeof (record->shared_key),
                                               &skey,
                                               &iv,
                                               &shared_key))
      return;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      &iv, sizeof (iv),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_decrypt (&(record->checksum),
                                               sizeof (record->checksum),
                                               &skey,
                                               &iv,
                                               &checksum))
      return;
 
    GNUNET_CRYPTO_zero_keys (&skey, sizeof (skey));
 
    if (checksum != GNUNET_CRYPTO_crc32_n (&shared_key, sizeof (shared_key)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Epoch key record failed checksum: %s\n",
                  GNUNET_h2s (&(record->key)));
      goto clear_key;
    }
  }
 
  if (identifier.code.group_bit)
  {
    struct GNUNET_MESSENGER_EpochGroup *group;
 
    group = get_epoch_group (epoch, &identifier, valid);
 
    if (! group)
      goto clear_key;
 
    set_epoch_group_key (group, &shared_key, GNUNET_NO);
  }
  else
  {
    struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
    announcement = get_epoch_announcement (epoch, &identifier, valid);
 
    if (! announcement)
      goto clear_key;
 
    set_epoch_announcement_key (announcement, &shared_key, GNUNET_NO);
  }
 
clear_key:
  GNUNET_CRYPTO_zero_keys (&shared_key, sizeof (shared_key));
}

References GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_announcement(), get_epoch_group(), get_handle_room(), get_room_epoch(), get_room_key(), GNUNET_assert, GNUNET_CRYPTO_crc32_n(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_symmetric_decrypt(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_FLAG_EPOCH_VALID, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, handle, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_EpochAnnouncement::identifier, GNUNET_MESSENGER_EpochGroup::identifier, GNUNET_MESSENGER_Room::key, record(), set_epoch_announcement_key(), set_epoch_group_key(), GNUNET_MESSENGER_EpochAnnouncement::shared_key, GNUNET_MESSENGER_EpochGroup::shared_key, GNUNET_MESSENGER_EpochAnnouncement::valid, and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by cb_key_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

read_handle_encryption_key()

static void read_handle_encryption_key ( struct GNUNET_MESSENGER_Handle *  handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const struct GNUNET_MESSENGER_EncryptionKeyRecord *  record  )

static

Definition at line 301 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
  struct GNUNET_CRYPTO_HpkePrivateKey encryption_key;
 
  GNUNET_assert ((handle) && (zone) && (record));
 
  room = get_handle_room (handle, &(record->key), GNUNET_YES);
 
  if (! room)
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Monitor encryption key record of room: %s\n",
              GNUNET_h2s (get_room_key (room)));
 
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey skey;
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
    uint8_t encryption_key_data[GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES];
    size_t encryption_key_len;
    int32_t encrypted_key_checksum;
 
    if (GNUNET_YES != GNUNET_CRYPTO_kdf (&skey, sizeof (skey),
                                         get_room_key (room),
                                         sizeof (room->key),
                                         &(handle->secret),
                                         sizeof (handle->secret),
                                         zone,
                                         sizeof (*zone),
                                         record->nonce_data,
                                         sizeof (record->nonce_data),
                                         NULL))
      return;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      get_room_key (room), sizeof (room->key),
      record->nonce_data, sizeof (record->nonce_data),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_decrypt (record->encrypted_key_data,
                                               sizeof (encryption_key_data),
                                               &skey,
                                               &iv,
                                               encryption_key_data))
      return;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      &iv, sizeof (iv),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_decrypt (&(record->encrypted_key_checksum)
                                               ,
                                               sizeof (encrypted_key_checksum),
                                               &skey,
                                               &iv,
                                               &encrypted_key_checksum))
      return;
 
    GNUNET_CRYPTO_zero_keys (&skey, sizeof (skey));
 
    if (encrypted_key_checksum != GNUNET_CRYPTO_crc32_n (encryption_key_data,
                                                         sizeof (
                                                           encryption_key_data))
        )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Encryption key record failed checksum: %s\n",
                  GNUNET_h2s (&(record->key)));
      return;
    }
 
    if (GNUNET_OK != GNUNET_CRYPTO_read_hpke_sk_from_buffer (
          encryption_key_data, record->encrypted_key_length, &encryption_key, &
          encryption_key_len))
      return;
 
    if (encryption_key_len < record->encrypted_key_length)
      goto clear_key;
  }
 
  add_room_encryption_key (room, &encryption_key);
 
clear_key:
  GNUNET_CRYPTO_hpke_sk_clear (&encryption_key);
}

References add_room_encryption_key(), get_handle_room(), get_room_key(), GNUNET_assert, GNUNET_CRYPTO_crc32_n(), GNUNET_CRYPTO_hpke_sk_clear(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_read_hpke_sk_from_buffer(), GNUNET_CRYPTO_symmetric_decrypt(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_Room::key, and record().

Referenced by cb_key_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_key_monitor()

static void cb_key_monitor ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Definition at line 398 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
 
  GNUNET_assert (
    (cls) && (zone) && (label) && (rd_count) && (rd));
 
  handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Monitor record with label: %s\n",
              label);
 
  switch (rd->record_type)
  {
  case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY:
    if ((sizeof (struct GNUNET_MESSENGER_RoomEpochKeyRecord) == rd->data_size)
        && (rd->data))
      read_handle_epoch_key (handle, zone, rd->data);
 
    break;
  case GNUNET_GNSRECORD_TYPE_MESSENGER_ENCRYPTION_KEY:
    if ((sizeof (struct GNUNET_MESSENGER_EncryptionKeyRecord) == rd->data_size)
        && (rd->data))
      read_handle_encryption_key (handle, zone, rd->data);
 
    break;
  default:
    break;
  }
 
  GNUNET_NAMESTORE_zone_monitor_next (handle->key_monitor, 1);
}

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_TYPE_MESSENGER_ENCRYPTION_KEY, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY, GNUNET_log, GNUNET_NAMESTORE_zone_monitor_next(), handle, rd, rd_count, read_handle_encryption_key(), read_handle_epoch_key(), and GNUNET_GNSRECORD_Data::record_type.

Referenced by set_handle_key().

Here is the call graph for this function:

Here is the caller graph for this function:

it_announcement_store_key()

static enum GNUNET_GenericReturnValue it_announcement_store_key ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 438 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert (value);
 
  announcement = value;
 
  if ((cls) && (GNUNET_YES != announcement->stored))
    write_epoch_announcement_record (announcement, GNUNET_NO);
  else if (! cls)
    announcement->stored = GNUNET_NO;
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochAnnouncement::stored, value, and write_epoch_announcement_record().

Referenced by it_epoch_store_keys().

Here is the call graph for this function:

Here is the caller graph for this function:

it_group_store_key()

static enum GNUNET_GenericReturnValue it_group_store_key ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 458 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert (value);
 
  group = value;
 
  if ((cls) && (GNUNET_YES != group->stored))
    write_epoch_group_record (group, GNUNET_NO);
  else if (! cls)
    group->stored = GNUNET_NO;
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochGroup::stored, value, and write_epoch_group_record().

Referenced by it_epoch_store_keys().

Here is the call graph for this function:

Here is the caller graph for this function:

it_epoch_store_keys()

static enum GNUNET_GenericReturnValue it_epoch_store_keys ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Definition at line 478 of file messenger_api_handle.c.

{
  const struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert (value);
 
  epoch = value;
 
  GNUNET_CONTAINER_multishortmap_iterate (epoch->announcements,
                                          it_announcement_store_key, cls);
  GNUNET_CONTAINER_multishortmap_iterate (epoch->groups, it_group_store_key,
                                          cls);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Epoch::announcements, GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_YES, GNUNET_MESSENGER_Epoch::groups, it_announcement_store_key(), it_group_store_key(), and value.

Referenced by it_room_store_keys().

Here is the call graph for this function:

Here is the caller graph for this function:

it_room_store_keys()

static enum GNUNET_GenericReturnValue it_room_store_keys ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Definition at line 497 of file messenger_api_handle.c.

{
  const struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert (value);
 
  room = value;
 
  GNUNET_CONTAINER_multihashmap_iterate (
    room->epochs,
    it_epoch_store_keys,
    cls);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Room::epochs, GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_YES, it_epoch_store_keys(), and value.

Referenced by cb_key_sync(), and set_handle_key().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_key_sync()

static void cb_key_sync ( void *  cls )

static

Definition at line 516 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
  const char *name;
 
  GNUNET_assert (cls);
 
  handle = cls;
  name = get_handle_name (handle);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Syncing keys from records completed: %s\n",
              name);
 
  GNUNET_CONTAINER_multihashmap_iterate (
    handle->rooms, it_room_store_keys, handle);
}

References get_handle_name(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, it_room_store_keys(), and name.

Referenced by set_handle_key().

Here is the call graph for this function:

Here is the caller graph for this function:

set_handle_key()

void set_handle_key	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_CRYPTO_BlindablePrivateKey *	key
	)

Sets the keypair of a given handle to the keypair of a specific private key.

Parameters

[in,out]	handle	Handle
[in]	key	Private key or NULL

Definition at line 536 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  if (handle->key_monitor)
  {
    GNUNET_NAMESTORE_zone_monitor_stop (handle->key_monitor);
    handle->key_monitor = NULL;
  }
 
  if (! key)
  {
    if (handle->key)
      GNUNET_free (handle->key);
 
    if (handle->pubkey)
      GNUNET_free (handle->pubkey);
 
    handle->key = NULL;
    handle->pubkey = NULL;
    return;
  }
 
  if (! handle->key)
    handle->key = GNUNET_new (struct GNUNET_CRYPTO_BlindablePrivateKey);
 
  if (! handle->pubkey)
    handle->pubkey = GNUNET_new (struct GNUNET_CRYPTO_BlindablePublicKey);
 
  GNUNET_memcpy (handle->key, key, sizeof(*key));
  GNUNET_CRYPTO_blindable_key_get_public (key, handle->pubkey);
 
  // Resets epoch and group keys as not stored yet
  GNUNET_CONTAINER_multihashmap_iterate (
    handle->rooms, it_room_store_keys, NULL);
 
  handle->key_monitor = GNUNET_NAMESTORE_zone_monitor_start2 (
    handle->config,
    handle->key,
    GNUNET_YES,
    cb_key_error,
    handle,
    cb_key_monitor,
    handle,
    cb_key_sync,
    handle,
    GNUNET_GNSRECORD_FILTER_NONE);
}

References cb_key_error(), cb_key_monitor(), cb_key_sync(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_free, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_memcpy, GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_new, GNUNET_YES, handle, it_room_store_keys(), and key.

Referenced by GNUNET_MESSENGER_connect(), and GNUNET_MESSENGER_set_key().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_key()

const struct GNUNET_CRYPTO_BlindablePrivateKey * get_handle_key

(

const struct GNUNET_MESSENGER_Handle *

handle

)

Returns the private key of a given handle.

Parameters

[in]

handle

Handle

Returns

Private key of the handle

Definition at line 588 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  if (handle->key)
    return handle->key;
 
  return get_anonymous_private_key ();
}

References get_anonymous_private_key(), GNUNET_assert, and handle.

Referenced by enqueue_message_to_room(), handle_member_id(), store_handle_encryption_key(), and store_handle_epoch_key().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_pubkey()

const struct GNUNET_CRYPTO_BlindablePublicKey * get_handle_pubkey

(

const struct GNUNET_MESSENGER_Handle *

handle

)

Returns the public key of a given handle.

Parameters

[in]

handle

Handle

Returns

Public key of the handle

Definition at line 600 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  if (handle->pubkey)
    return handle->pubkey;
 
  return get_anonymous_public_key ();
}

References get_anonymous_public_key(), GNUNET_assert, and handle.

Referenced by get_handle_contact(), GNUNET_MESSENGER_get_key(), handle_join_message(), send_enter_room(), send_message_to_room_with_key(), and send_open_room().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_contact_store()

struct GNUNET_MESSENGER_ContactStore * get_handle_contact_store

(

struct GNUNET_MESSENGER_Handle *

handle

)

Returns the used contact store of a given handle.

Parameters

[in,out]

handle

Handle

Returns

Contact store

Definition at line 612 of file messenger_api_handle.c.

{
  GNUNET_assert (handle);
 
  return &(handle->contact_store);
}

References GNUNET_assert, and handle.

Referenced by create_handle(), destroy_handle(), get_handle_contact(), handle_id_message(), handle_join_message(), handle_key_message(), handle_transcript_message(), process_message_control(), and task_message_control().

Here is the caller graph for this function:

get_handle_contact()

struct GNUNET_MESSENGER_Contact * get_handle_contact	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key
	)

Returns the contact of a given handle in a room identified by a given key.

Parameters

[in,out]	handle	Handle
[in]	key	Key of room

Returns

Contact

Definition at line 621 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_ShortHashCode *contact_id;
 
  GNUNET_assert ((handle) && (key));
 
  room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
  if (! room)
    return NULL;
 
  contact_id = get_room_sender_id (room);
 
  if (! contact_id)
    return NULL;
 
  {
    struct GNUNET_HashCode context;
    get_context_from_member (key, contact_id, &context);
 
    return get_store_contact (get_handle_contact_store (handle),
                              &context,
                              get_handle_pubkey (handle));
  }
}

References context, get_context_from_member(), get_handle_contact_store(), get_handle_pubkey(), get_room_sender_id(), get_store_contact(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), handle, and key.

Referenced by get_room_availble_epoch_entry(), handle_appeal_message(), handle_epoch_announcement(), and handle_private_message().

Here is the call graph for this function:

Here is the caller graph for this function:

open_handle_room()

void open_handle_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key
	)

Marks a room known to a handle identified by a given key as open.

Parameters

[in,out]	handle	Handle
[in]	key	Key of room

Definition at line 651 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((handle) && (key));
 
  room = get_handle_room (handle, key, GNUNET_YES);
 
  if (room)
    room->opened = GNUNET_YES;
}

References get_handle_room(), GNUNET_assert, GNUNET_YES, handle, key, and GNUNET_MESSENGER_Room::opened.

Referenced by handle_room_open().

Here is the call graph for this function:

Here is the caller graph for this function:

entry_handle_room_at()

void entry_handle_room_at	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_PeerIdentity *	door,
		const struct GNUNET_HashCode *	key
	)

Adds a tunnel for a room known to a handle identified by a given key to a list of opened connections.

Parameters

[in,out]	handle	Handle
[in]	door	Peer identity
[in]	key	Key of room

Definition at line 666 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((handle) && (door) && (key));
 
  room = get_handle_room (handle, key, GNUNET_YES);
 
  if (room)
    add_to_list_tunnels (&(room->entries), door, NULL);
}

References add_to_list_tunnels(), GNUNET_MESSENGER_Room::entries, get_handle_room(), GNUNET_assert, GNUNET_YES, handle, and key.

Referenced by handle_room_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

close_handle_room()

void close_handle_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key
	)

Destroys and so implicitly closes a room known to a handle identified by a given key.

Parameters

[in,out]	handle	Handle
[in]	key	Key of room

Definition at line 682 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((handle) && (key));
 
  room = get_handle_room (handle, key, GNUNET_YES);
 
  if ((room) && (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
                   handle->rooms, key, room)))
    destroy_room (room);
}

References destroy_room(), get_handle_room(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_YES, handle, and key.

Referenced by handle_room_close().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_room()

struct GNUNET_MESSENGER_Room * get_handle_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_GenericReturnValue	init
	)

Returns the room known to a handle identified by a given key.

Parameters

[in,out]	handle	handle Handle
[in]	key	Key of room
[in]	init	Creates room if necessary when GNUNET_YES is provided

Returns

Room or NULL

Definition at line 698 of file messenger_api_handle.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  GNUNET_assert ((handle) && (key));
 
  room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
  if ((! room) && (GNUNET_YES == init))
  {
    union GNUNET_MESSENGER_RoomKey room_key;
    GNUNET_memcpy (&(room_key.hash), key, sizeof (struct GNUNET_HashCode));
 
    room = create_room (handle, &room_key);
 
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
          handle->rooms, key, room,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      destroy_room (room);
      return NULL;
    }
  }
 
  return room;
}

References create_room(), destroy_room(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_memcpy, GNUNET_OK, GNUNET_YES, handle, init, key, and room_key.

Referenced by close_handle_room(), entry_handle_room_at(), GNUNET_MESSENGER_enter_room(), GNUNET_MESSENGER_open_room(), handle_member_id(), handle_miss_message(), handle_recv_message(), handle_room_close(), handle_room_entry(), handle_room_open(), handle_room_sync(), open_handle_room(), read_handle_encryption_key(), and read_handle_epoch_key().

Here is the call graph for this function:

Here is the caller graph for this function:

store_handle_epoch_key()

enum GNUNET_GenericReturnValue store_handle_epoch_key	(	const struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_ShortHashCode *	identifier,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key,
		uint32_t	flags,
		GNUNET_NAMESTORE_ContinuationWithStatus	cont,
		void *	cont_cls,
		struct GNUNET_NAMESTORE_QueueEntry **	query
	)

Stores/deletes a shared_key for a given room from a handle identified by its key in an epoch with certain hash using a specific identifier for this epoch key.

Parameters

[in]	handle	Handle
[in]	key	Room key
[in]	hash	Epoch hash
[in]	identifier	Epoch key identifier
[in]	shared_key	Shared epoch key or NULL
[in]	flags	Epoch key flags
[in]	cont	Continuation status callback or NULL
[in]	cont_cls	Continuation closure or NULL
[out]	query

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 729 of file messenger_api_handle.c.

{
  const struct GNUNET_CRYPTO_BlindablePrivateKey *zone;
  struct GNUNET_TIME_Absolute expiration;
  struct GNUNET_GNSRECORD_Data data;
  struct GNUNET_MESSENGER_RoomEpochKeyRecord record;
  char *label;
 
  GNUNET_assert ((handle) && (key) && (hash) && (identifier) && (query));
 
  if (! handle->namestore)
    return GNUNET_SYSERR;
 
  zone = get_handle_key (handle);
 
  if (! zone)
    return GNUNET_SYSERR;
 
  expiration = GNUNET_TIME_absolute_get_forever_ ();
 
  memset (&data, 0, sizeof (data));
  memset (&record, 0, sizeof (record));
 
  if (shared_key)
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey skey;
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
    int32_t checksum;
 
    if (GNUNET_YES != GNUNET_CRYPTO_kdf (&skey, sizeof (skey),
                                         key, sizeof (*key),
                                         &(handle->secret),
                                         sizeof (handle->secret),
                                         zone, sizeof (*zone),
                                         hash, sizeof (*hash),
                                         identifier, sizeof (*identifier),
                                         NULL))
      return GNUNET_SYSERR;
 
    GNUNET_memcpy (&(record.key), key, sizeof (record.key));
    GNUNET_memcpy (&(record.hash), hash, sizeof (record.hash));
    GNUNET_memcpy (
      &(record.identifier),
      identifier,
      sizeof (record.identifier));
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      key, sizeof (*key),
      hash, sizeof (*hash),
      identifier, sizeof (*identifier),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_encrypt (shared_key,
                                               sizeof (*shared_key),
                                               &skey,
                                               &iv,
                                               &(record.shared_key)))
      return GNUNET_SYSERR;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      &iv, sizeof (iv),
      NULL);
 
    checksum = GNUNET_CRYPTO_crc32_n (shared_key, sizeof (*shared_key));
 
    if (-1 == GNUNET_CRYPTO_symmetric_encrypt (&checksum,
                                               sizeof (checksum),
                                               &skey,
                                               &iv,
                                               &(record.checksum)))
      return GNUNET_SYSERR;
 
    record.flags = flags;
 
    data.record_type = GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY;
    data.data = &record;
    data.data_size = sizeof (record);
    data.expiration_time = expiration.abs_value_us;
    data.flags = GNUNET_GNSRECORD_RF_PRIVATE;
 
    GNUNET_CRYPTO_zero_keys (&skey, sizeof (skey));
  }
 
  {
    char lower_key [9];
    char lower_hash [9];
    char lower_id [7];
    const char *s;
 
    memset (lower_key, 0, sizeof (lower_key));
    memset (lower_hash, 0, sizeof (lower_hash));
    memset (lower_id, 0, sizeof (lower_id));
 
    s = GNUNET_h2s (key);
    for (size_t i=0; '\0' != s[i]; i++)
    {
      GNUNET_assert (i < sizeof (lower_key));
      lower_key[i] = (char) tolower ((int) s[i]);
    }
    s = GNUNET_h2s (hash);
    for (size_t i=0; '\0' != s[i]; i++)
    {
      GNUNET_assert (i < sizeof (lower_hash));
      lower_hash[i] = (char) tolower ((int) s[i]);
    }
 
    s = GNUNET_sh2s (identifier);
    for (size_t i=0; '\0' != s[i]; i++)
    {
      GNUNET_assert (i < sizeof (lower_id));
      lower_id[i] = (char) tolower ((int) s[i]);
    }
 
    GNUNET_asprintf (
      &label,
      "epoch_key_%s%s%s",
      lower_key,
      lower_hash,
      lower_id);
  }
 
  if (! label)
    return GNUNET_SYSERR;
 
  if (*query)
    GNUNET_NAMESTORE_cancel (*query);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Store epoch key record with label: %s [%d]\n",
              label,
              shared_key? 1 : 0);
 
  *query = GNUNET_NAMESTORE_record_set_store (
    handle->namestore,
    zone,
    label,
    shared_key? 1 : 0,
    &data,
    cont,
    cont_cls);
 
  GNUNET_free (label);
  return GNUNET_OK;
}

References data, expiration, get_handle_key(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_crc32_n(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_record_set_store(), GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_forever_(), GNUNET_YES, handle, GNUNET_MESSENGER_RoomEpochKeyRecord::hash, GNUNET_MESSENGER_RoomEpochKeyRecord::identifier, key, record(), and GNUNET_MESSENGER_RoomEpochKeyRecord::shared_key.

Referenced by write_epoch_announcement_record(), and write_epoch_group_record().

Here is the call graph for this function:

Here is the caller graph for this function:

store_handle_encryption_key()

enum GNUNET_GenericReturnValue store_handle_encryption_key	(	const struct GNUNET_MESSENGER_Handle *	handle,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_CRYPTO_HpkePrivateKey *	encryption_key,
		GNUNET_NAMESTORE_ContinuationWithStatus	cont,
		void *	cont_cls,
		struct GNUNET_NAMESTORE_QueueEntry **	query
	)

Stores an encryption_key for a given room from a handle identified by its key/i>.

Parameters

[in]	handle	Handle
[in]	key	Room key
[in]	encryption_key	Encryption key or NULL
[in]	cont	Continuation status callback or NULL
[in]	cont_cls	Continuation closure or NULL
[out]	query

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 889 of file messenger_api_handle.c.

{
  const struct GNUNET_CRYPTO_BlindablePrivateKey *zone;
  struct GNUNET_TIME_Absolute expiration;
  struct GNUNET_GNSRECORD_Data data;
  struct GNUNET_MESSENGER_EncryptionKeyRecord record;
  struct GNUNET_HashCode nonce_hash;
  char *label;
 
  GNUNET_assert ((handle) && (key) && (encryption_key) && (query));
 
  if (! handle->namestore)
    return GNUNET_SYSERR;
 
  zone = get_handle_key (handle);
 
  if (! zone)
    return GNUNET_SYSERR;
 
  expiration = GNUNET_TIME_absolute_get_forever_ ();
 
  memset (&data, 0, sizeof (data));
 
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey skey;
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
    uint8_t encryption_key_data [GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES];
    int32_t encryption_key_checksum;
    size_t encryption_key_len;
    ssize_t offset;
 
    encryption_key_len = GNUNET_CRYPTO_hpke_sk_get_length (encryption_key);
 
    if ((0 > encryption_key_len) || (encryption_key_len >
                                     GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES)
        )
      return GNUNET_SYSERR;
 
    GNUNET_memcpy (&(record.key), key, sizeof (record.key));
    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, record.nonce_data,
                                GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES);
 
    if (GNUNET_YES != GNUNET_CRYPTO_kdf (&skey, sizeof (skey),
                                         key, sizeof (*key),
                                         &(handle->secret),
                                         sizeof (handle->secret),
                                         zone, sizeof (*zone),
                                         record.nonce_data, sizeof (record.
                                                                    nonce_data),
                                         NULL))
      return GNUNET_SYSERR;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      key, sizeof (*key),
      record.nonce_data, sizeof (record.nonce_data),
      NULL);
 
    offset = GNUNET_CRYPTO_write_hpke_sk_to_buffer (
      encryption_key, encryption_key_data, encryption_key_len);
 
    if (offset < 0)
      return GNUNET_SYSERR;
 
    if (offset < encryption_key_len)
      encryption_key_len = offset;
 
    record.encrypted_key_length = encryption_key_len;
 
    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, encryption_key_data
                                + encryption_key_len,
                                sizeof (encryption_key_data)
                                - encryption_key_len);
 
    encryption_key_checksum = GNUNET_CRYPTO_crc32_n (encryption_key_data,
                                                     sizeof (encryption_key_data
                                                             ));
 
    if (-1 == GNUNET_CRYPTO_symmetric_encrypt (encryption_key_data,
                                               sizeof (encryption_key_data),
                                               &skey,
                                               &iv,
                                               record.encrypted_key_data))
      return GNUNET_SYSERR;
 
    GNUNET_CRYPTO_symmetric_derive_iv (
      &iv,
      &skey,
      &iv, sizeof (iv),
      NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_encrypt (&encryption_key_checksum,
                                               sizeof (encryption_key_checksum),
                                               &skey,
                                               &iv,
                                               &(record.encrypted_key_checksum))
        )
      return GNUNET_SYSERR;
 
    GNUNET_CRYPTO_hash (record.nonce_data, sizeof (record.nonce_data), &
                        nonce_hash);
 
    data.record_type = GNUNET_GNSRECORD_TYPE_MESSENGER_ENCRYPTION_KEY;
    data.data = &record;
    data.data_size = sizeof (record);
    data.expiration_time = expiration.abs_value_us;
    data.flags = GNUNET_GNSRECORD_RF_PRIVATE;
 
    GNUNET_CRYPTO_zero_keys (&skey, sizeof (skey));
  }
 
  {
    char *lower_key;
    char *lower_nonce;
    const char *s;
 
    s = GNUNET_h2s (key);
    lower_key = GNUNET_STRINGS_utf8_tolower (s);
    if (! lower_key)
      lower_key = GNUNET_strdup (s);
 
    s = GNUNET_h2s (&nonce_hash);
    lower_nonce = GNUNET_STRINGS_utf8_tolower (s);
    if (! lower_nonce)
      lower_nonce = GNUNET_strdup (s);
 
    GNUNET_asprintf (
      &label,
      "encryption_key_%s%s",
      lower_key,
      lower_nonce);
 
    if (lower_nonce)
      GNUNET_free (lower_nonce);
    if (lower_key)
      GNUNET_free (lower_key);
  }
 
  if (! label)
    return GNUNET_SYSERR;
 
  if (*query)
    GNUNET_NAMESTORE_cancel (*query);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Store encryption key record with label: %s [%d]\n",
              label,
              encryption_key? 1 : 0);
 
  *query = GNUNET_NAMESTORE_record_set_store (
    handle->namestore,
    zone,
    label,
    encryption_key? 1 : 0,
    &data,
    cont,
    cont_cls);
 
  GNUNET_free (label);
  return GNUNET_OK;
}

References data, expiration, get_handle_key(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_crc32_n(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hpke_sk_get_length(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_CRYPTO_write_hpke_sk_to_buffer(), GNUNET_CRYPTO_zero_keys(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_TYPE_MESSENGER_ENCRYPTION_KEY, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES, GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_record_set_store(), GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_forever_(), GNUNET_YES, handle, key, and record().

Referenced by add_room_encryption_key().

Here is the call graph for this function:

Here is the caller graph for this function: