gnunet-service-revocation.c File Reference

key revocation service More...

#include "platform.h"
#include <math.h>
#include "gnunet_util_lib.h"
#include "gnunet_block_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_core_service.h"
#include "gnunet_revocation_service.h"
#include "gnunet_setu_service.h"
#include "revocation.h"
#include <gcrypt.h>

Include dependency graph for gnunet-service-revocation.c:

Go to the source code of this file.

Data Structures
struct	PeerEntry
	Per-peer information. More...

Functions
static struct PeerEntry *	new_peer_entry (const struct GNUNET_PeerIdentity *peer)
	Create a new PeerEntry and add it to the peers multipeermap. More...
static enum GNUNET_GenericReturnValue	verify_revoke_message (const struct RevokeMessage *rm)
	An revoke message has been received, check that it is well-formed. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Handle client connecting to the service. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
	Handle client connecting to the service. More...
static int	check_query_message (void *cls, const struct QueryMessage *qm)
static void	handle_query_message (void *cls, const struct QueryMessage *qm)
	Handle QUERY message from client. More...
static enum GNUNET_GenericReturnValue	do_flood (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
	Flood the given revocation message to all neighbours. More...
static enum GNUNET_GenericReturnValue	publicize_rm (const struct RevokeMessage *rm)
	Publicize revocation message. More...
static int	check_revoke_message (void *cls, const struct RevokeMessage *rm)
static void	handle_revoke_message (void *cls, const struct RevokeMessage *rm)
	Handle REVOKE message from client. More...
static int	check_p2p_revoke (void *cls, const struct RevokeMessage *rm)
static void	handle_p2p_revoke (void *cls, const struct RevokeMessage *rm)
	Core handler for flooded revocation messages. More...
static void	add_revocation (void *cls, const struct GNUNET_SETU_Element *element, uint64_t current_size, enum GNUNET_SETU_Status status)
	Callback for set operation results. More...
static void	transmit_task_cb (void *cls)
	The timeout for performing the set union has expired, run the set operation on the revocation certificates. More...
static void *	handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a peer connects. More...
static void	handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Method called whenever a peer disconnects. More...
static int	free_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free all values in a hash map. More...
static void	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
	Called on core init/fail. More...
static void	handle_revocation_union_request (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETU_Request *request)
	Called when another peer wants to do a set operation with the local peer. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Handle network size estimate clients. More...
	GNUNET_SERVICE_MAIN ("revocation", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(query_message, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, struct QueryMessage, NULL), GNUNET_MQ_hd_var_size(revoke_message, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, struct RevokeMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_SETU_Handle *	revocation_set
	Set from all revocations known to us. More...
static struct GNUNET_CONTAINER_MultiHashMap *	revocation_map
	Hash map with all revoked keys, maps the hash of the public key to the respective struct RevokeMessage. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our current configuration. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service. More...
static struct GNUNET_CORE_Handle *	core_api
	Handle to the core service (for flooding) More...
static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	Map of all connected peers. More...
static struct GNUNET_PeerIdentity	my_identity
	The peer identity of this peer. More...
static struct GNUNET_DISK_FileHandle *	revocation_db
	File handle for the revocation database. More...
static struct GNUNET_SETU_ListenHandle *	revocation_union_listen_handle
	Handle for us listening to incoming revocation set union requests. More...
static unsigned long long	revocation_work_required
	Amount of work required (W-bit collisions) for REVOCATION proofs, in collision-bits. More...
static struct GNUNET_TIME_Relative	epoch_duration
	Length of an expiration expoch. More...
static struct GNUNET_HashCode	revocation_set_union_app_id
	Our application ID for set union operations. More...

Detailed Description

key revocation service

Author

Christian Grothoff

The purpose of this service is to allow users to permanently revoke (compromised) keys. This is done by flooding the network with the revocation requests. To reduce the attack potential offered by such flooding, revocations must include a proof of work. We use the set service for efficiently computing the union of revocations of peers that connect.

TODO:

• optimization: avoid sending revocation back to peer that we got it from;
• optimization: have randomized delay in sending revocations to other peers to make it rare to traverse each link twice (NSE-style)

Definition in file gnunet-service-revocation.c.

Function Documentation

new_peer_entry()

static struct PeerEntry* new_peer_entry ( const struct GNUNET_PeerIdentity *  peer )

static

Create a new PeerEntry and add it to the peers multipeermap.

Parameters

peer	the peer identity

Returns

a pointer to the new PeerEntry

Definition at line 150 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry;
 
  peer_entry = GNUNET_new (struct PeerEntry);
  peer_entry->id = *peer;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (peers,
                                                    &peer_entry->id,
                                                    peer_entry,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return peer_entry;
}

References GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_new, GNUNET_OK, PeerEntry::id, peer, and peers.

Referenced by handle_core_connect(), and handle_revocation_union_request().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_revoke_message()

static enum GNUNET_GenericReturnValue verify_revoke_message ( const struct RevokeMessage *  rm )

static

An revoke message has been received, check that it is well-formed.

Parameters

rm	the message to verify

Returns

GNUNET_YES if the message is verified GNUNET_NO if the key/signature don't verify

Definition at line 150 of file gnunet-service-revocation.c.

{
  const struct GNUNET_REVOCATION_PowP *pow
    = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
 
  if (GNUNET_YES !=
      GNUNET_REVOCATION_check_pow (pow,
                                   (unsigned int) revocation_work_required,
                                   epoch_duration))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Proof of work invalid!\n");
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

client_connect_cb()

static void* client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Handle client connecting to the service.

Parameters

cls	NULL
client	the new client
mq	the message queue of client

Returns

client

Definition at line 201 of file gnunet-service-revocation.c.

{
  return client;
}

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_cls  )

static

Handle client connecting to the service.

Parameters

cls	NULL
client	the new client
app_cls	must alias client

Definition at line 217 of file gnunet-service-revocation.c.

{
  GNUNET_assert (client == app_cls);
}

References GNUNET_assert.

check_query_message()

static int check_query_message ( void *  cls, const struct QueryMessage *  qm  )

static

Definition at line 225 of file gnunet-service-revocation.c.

{
  uint16_t size;
 
  size = ntohs (qm->header.size);
  if (size <= sizeof(struct RevokeMessage) ||
      (size > UINT16_MAX))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
 
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, QueryMessage::header, GNUNET_MessageHeader::size, and size.

handle_query_message()

static void handle_query_message ( void *  cls, const struct QueryMessage *  qm  )

static

Handle QUERY message from client.

Parameters

cls	client who sent the message
qm	the message received

Definition at line 249 of file gnunet-service-revocation.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_IDENTITY_PublicKey zone;
  struct GNUNET_MQ_Envelope *env;
  struct QueryResponseMessage *qrm;
  struct GNUNET_HashCode hc;
  int res;
  size_t key_len;
  size_t read;
 
  key_len = ntohl (qm->key_len);
  if ((GNUNET_SYSERR ==
       GNUNET_IDENTITY_read_public_key_from_buffer (&qm[1], key_len,
                                                    &zone, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse query public key\n");
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  GNUNET_CRYPTO_hash (&qm[1],
                      key_len,
                      &hc);
  res = GNUNET_CONTAINER_multihashmap_contains (revocation_map,
                                                &hc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              (GNUNET_NO == res)
              ? "Received revocation check for valid key `%s' from client\n"
              : "Received revocation check for revoked key `%s' from client\n",
              GNUNET_h2s (&hc));
  env = GNUNET_MQ_msg (qrm,
                       GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE);
  qrm->is_valid = htonl ((GNUNET_YES == res) ? GNUNET_NO : GNUNET_YES);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
  GNUNET_SERVICE_client_continue (client);
}

do_flood()

static enum GNUNET_GenericReturnValue do_flood ( void *  cls, const struct GNUNET_PeerIdentity *  target, void *  value  )

static

Flood the given revocation message to all neighbours.

Parameters

cls	the struct RevokeMessage to flood
target	a neighbour
value	our struct PeerEntry for the neighbour

Returns

GNUNET_OK (continue to iterate)

Definition at line 249 of file gnunet-service-revocation.c.

{
  const struct RevokeMessage *rm = cls;
  struct PeerEntry *pe = value;
  struct GNUNET_MQ_Envelope *e;
  struct RevokeMessage *cp;
 
  if (NULL == pe->mq)
    return GNUNET_OK; /* peer connected to us via SET,
                         but we have no direct CORE
                         connection for flooding */
  e = GNUNET_MQ_msg_extra (cp,
                           htonl (rm->pow_size),
                           GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE);
  *cp = *rm;
  memcpy (&cp[1],
          &rm[1],
          htonl (rm->pow_size));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Flooding revocation to `%s'\n",
              GNUNET_i2s (target));
  GNUNET_MQ_send (pe->mq,
                  e);
  return GNUNET_OK;
}

References env, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_IDENTITY_read_public_key_from_buffer(), GNUNET_log, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_SYSERR, GNUNET_YES, QueryResponseMessage::is_valid, QueryMessage::key_len, res, revocation_map, and zone.

Here is the call graph for this function:

publicize_rm()

static enum GNUNET_GenericReturnValue publicize_rm ( const struct RevokeMessage *  rm )

static

Publicize revocation message.

Stores the message locally in the database and passes it to all connected neighbours (and adds it to the set for future connections).

Parameters

rm	message to publicize

Returns

GNUNET_OK on success, GNUNET_NO if we encountered an error, GNUNET_SYSERR if the message was malformed

FIXME yeah this works, but should we have a key length somewhere?

Definition at line 249 of file gnunet-service-revocation.c.

{
  struct RevokeMessage *cp;
  struct GNUNET_HashCode hc;
  struct GNUNET_SETU_Element e;
  ssize_t pklen;
  const struct GNUNET_REVOCATION_PowP *pow
    = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
  const struct GNUNET_IDENTITY_PublicKey *pk
    = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
 
  pklen = GNUNET_IDENTITY_public_key_get_length (pk);
  if (0 > pklen)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_CRYPTO_hash (pk,
                      pklen,
                      &hc);
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (revocation_map,
                                              &hc))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Duplicate revocation received from peer. Ignored.\n");
    return GNUNET_OK;
  }
  if (GNUNET_OK !=
      verify_revoke_message (rm))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  /* write to disk */
  if (sizeof(struct RevokeMessage) !=
      GNUNET_DISK_file_write (revocation_db,
                              rm,
                              sizeof(struct RevokeMessage)))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "write");
    return GNUNET_NO;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_sync (revocation_db))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "sync");
    return GNUNET_NO;
  }
  /* keep copy in memory */
  cp = (struct RevokeMessage *) GNUNET_copy_message (&rm->header);
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multihashmap_put (revocation_map,
                                                   &hc,
                                                   cp,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  /* add to set for future connections */
  e.size = htons (rm->header.size);
  e.element_type = GNUNET_BLOCK_TYPE_REVOCATION;
  e.data = rm;
  if (GNUNET_OK !=
      GNUNET_SETU_add_element (revocation_set,
                               &e,
                               NULL,
                               NULL))
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Added revocation info to SET\n");
  }
  /* flood to neighbours */
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &do_flood,
                                         cp);
  return GNUNET_OK;
}

Referenced by handle_p2p_revoke(), and handle_revoke_message().

Here is the caller graph for this function:

check_revoke_message()

static int check_revoke_message ( void *  cls, const struct RevokeMessage *  rm  )

static

Definition at line 425 of file gnunet-service-revocation.c.

{
  uint16_t size;
 
  size = ntohs (rm->header.size);
  if (size <= sizeof(struct RevokeMessage) ||
      (size > UINT16_MAX))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
 
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, RevokeMessage::header, GNUNET_MessageHeader::size, and size.

handle_revoke_message()

static void handle_revoke_message ( void *  cls, const struct RevokeMessage *  rm  )

static

Handle REVOKE message from client.

Parameters

cls	client who sent the message
rm	the message received

Definition at line 449 of file gnunet-service-revocation.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Envelope *env;
  struct RevocationResponseMessage *rrm;
  int ret;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received REVOKE message from client\n");
  if (GNUNET_SYSERR == (ret = publicize_rm (rm)))
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  env = GNUNET_MQ_msg (rrm,
                       GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE);
  rrm->is_valid = htonl ((GNUNET_OK == ret) ? GNUNET_NO : GNUNET_YES);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
  GNUNET_SERVICE_client_continue (client);
}

References env, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_SYSERR, GNUNET_YES, RevocationResponseMessage::is_valid, publicize_rm(), and ret.

Here is the call graph for this function:

check_p2p_revoke()

static int check_p2p_revoke ( void *  cls, const struct RevokeMessage *  rm  )

static

Definition at line 475 of file gnunet-service-revocation.c.

{
  uint16_t size;
 
  size = ntohs (rm->header.size);
  if (size <= sizeof(struct RevokeMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
 
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, RevokeMessage::header, GNUNET_MessageHeader::size, and size.

handle_p2p_revoke()

static void handle_p2p_revoke ( void *  cls, const struct RevokeMessage *  rm  )

static

Core handler for flooded revocation messages.

Parameters

cls	closure unused
rm	revocation message

Definition at line 498 of file gnunet-service-revocation.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received REVOKE message\n");
  GNUNET_break_op (GNUNET_SYSERR !=
                   publicize_rm (rm));
}

References GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SYSERR, and publicize_rm().

Referenced by add_revocation().

Here is the call graph for this function:

Here is the caller graph for this function:

add_revocation()

static void add_revocation ( void *  cls, const struct GNUNET_SETU_Element *  element, uint64_t  current_size, enum GNUNET_SETU_Status  status  )

static

Callback for set operation results.

Called for each element in the result set. Each element contains a revocation, which we should validate and then add to our revocation list (and set).

Parameters

cls	closure
element	a result element, only valid if status is #GNUNET_SETU_STATUS_OK
current_size	current set size
status	see enum GNUNET_SETU_Status

Definition at line 519 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry = cls;
  const struct RevokeMessage *rm;
 
  switch (status)
  {
  case GNUNET_SETU_STATUS_ADD_LOCAL:
    if (element->size != sizeof(struct RevokeMessage))
    {
      GNUNET_break_op (0);
      return;
    }
    if (GNUNET_BLOCK_TYPE_REVOCATION != element->element_type)
    {
      GNUNET_STATISTICS_update (stats,
                                gettext_noop (
                                  "# unsupported revocations received via set union"),
                                1,
                                GNUNET_NO);
      return;
    }
    rm = element->data;
    (void) handle_p2p_revoke (NULL,
                              rm);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# revocation messages received via set union"),
                              1, GNUNET_NO);
    break;
  case GNUNET_SETU_STATUS_FAILURE:
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Error computing revocation set union with %s\n"),
                GNUNET_i2s (&peer_entry->id));
    peer_entry->so = NULL;
    GNUNET_STATISTICS_update (stats,
                              gettext_noop ("# revocation set unions failed"),
                              1,
                              GNUNET_NO);
    break;
  case GNUNET_SETU_STATUS_DONE:
    peer_entry->so = NULL;
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# revocation set unions completed"),
                              1,
                              GNUNET_NO);
    break;
  default:
    GNUNET_break (0);
    break;
  }
}

References _, GNUNET_SETU_Element::data, GNUNET_SETU_Element::element_type, gettext_noop, GNUNET_BLOCK_TYPE_REVOCATION, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SETU_STATUS_ADD_LOCAL, GNUNET_SETU_STATUS_DONE, GNUNET_SETU_STATUS_FAILURE, GNUNET_STATISTICS_update(), handle_p2p_revoke(), PeerEntry::id, GNUNET_SETU_Element::size, PeerEntry::so, stats, and status.

Referenced by handle_revocation_union_request().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_task_cb()

static void transmit_task_cb ( void *  cls )

static

The timeout for performing the set union has expired, run the set operation on the revocation certificates.

Parameters

cls

NULL

Definition at line 584 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting set exchange with peer `%s'\n",
              GNUNET_i2s (&peer_entry->id));
  peer_entry->transmit_task = NULL;
  GNUNET_assert (NULL == peer_entry->so);
  peer_entry->so = GNUNET_SETU_prepare (&peer_entry->id,
                                        &revocation_set_union_app_id,
                                        NULL,
                                        (struct GNUNET_SETU_Option[]) { { 0 } },
                                        &add_revocation,
                                        peer_entry);
  if (GNUNET_OK !=
      GNUNET_SETU_commit (peer_entry->so,
                          revocation_set))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("SET service crashed, terminating revocation service\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SETU_prepare(), PeerEntry::id, revocation_set_union_app_id, PeerEntry::so, and PeerEntry::transmit_task.

Referenced by handle_core_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_core_connect()

static void* handle_core_connect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a peer connects.

Sets up the PeerEntry and schedules the initial revocation set exchange with this peer.

Parameters

cls	closure
peer	peer identity this notification is about

Definition at line 619 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry;
  struct GNUNET_HashCode my_hash;
  struct GNUNET_HashCode peer_hash;
 
  if (0 == GNUNET_memcmp (peer,
                          &my_identity))
  {
    return NULL;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' connected to us\n",
              GNUNET_i2s (peer));
  GNUNET_STATISTICS_update (stats,
                            "# peers connected",
                            1,
                            GNUNET_NO);
  peer_entry = GNUNET_CONTAINER_multipeermap_get (peers,
                                                  peer);
  if (NULL != peer_entry)
  {
    /* This can happen if "core"'s notification is a tad late
       and CADET+SET were faster and already produced a
     #handle_revocation_union_request() for us to deal
       with.  This should be rare, but isn't impossible. */
    peer_entry->mq = mq;
    return peer_entry;
  }
  peer_entry = new_peer_entry (peer);
  peer_entry->mq = mq;
  GNUNET_CRYPTO_hash (&my_identity,
                      sizeof(my_identity),
                      &my_hash);
  GNUNET_CRYPTO_hash (peer,
                      sizeof(*peer),
                      &peer_hash);
  if (0 < GNUNET_CRYPTO_hash_cmp (&my_hash,
                                  &peer_hash))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Starting SET operation with peer `%s'\n",
                GNUNET_i2s (peer));
    peer_entry->transmit_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                    &transmit_task_cb,
                                    peer_entry);
  }
  return peer_entry;
}

References GNUNET_CONTAINER_multipeermap_get(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_SECONDS, mq, PeerEntry::mq, my_identity, new_peer_entry(), peer, peers, stats, PeerEntry::transmit_task, and transmit_task_cb().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_core_disconnect()

static void handle_core_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Method called whenever a peer disconnects.

Deletes the PeerEntry and cancels any pending transmission requests to that peer.

Parameters

cls	closure
peer	peer identity this notification is about
internal_cls	our struct PeerEntry for this peer

Definition at line 683 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry = internal_cls;
 
  if (0 == GNUNET_memcmp (peer,
                          &my_identity))
    return;
  GNUNET_assert (NULL != peer_entry);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' disconnected from us\n",
              GNUNET_i2s (peer));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers,
                                                       peer,
                                                       peer_entry));
  if (NULL != peer_entry->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->transmit_task = NULL;
  }
  if (NULL != peer_entry->so)
  {
    GNUNET_SETU_operation_cancel (peer_entry->so);
    peer_entry->so = NULL;
  }
  GNUNET_free (peer_entry);
  GNUNET_STATISTICS_update (stats,
                            "# peers connected",
                            -1,
                            GNUNET_NO);
}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SETU_operation_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, my_identity, peer, peers, PeerEntry::so, stats, and PeerEntry::transmit_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

free_entry()

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

static

Free all values in a hash map.

Parameters

cls	NULL
key	the key
value	value to free

Returns

GNUNET_OK (continue to iterate)

Definition at line 727 of file gnunet-service-revocation.c.

{
  GNUNET_free (value);
  return GNUNET_OK;
}

References GNUNET_free, GNUNET_OK, and value.

Referenced by shutdown_task().

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 742 of file gnunet-service-revocation.c.

{
  if (NULL != revocation_set)
  {
    GNUNET_SETU_destroy (revocation_set);
    revocation_set = NULL;
  }
  if (NULL != revocation_union_listen_handle)
  {
    GNUNET_SETU_listen_cancel (revocation_union_listen_handle);
    revocation_union_listen_handle = NULL;
  }
  if (NULL != core_api)
  {
    GNUNET_CORE_disconnect (core_api);
    core_api = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  if (NULL != peers)
  {
    GNUNET_CONTAINER_multipeermap_destroy (peers);
    peers = NULL;
  }
  if (NULL != revocation_db)
  {
    GNUNET_DISK_file_close (revocation_db);
    revocation_db = NULL;
  }
  GNUNET_CONTAINER_multihashmap_iterate (revocation_map,
                                         &free_entry,
                                         NULL);
  GNUNET_CONTAINER_multihashmap_destroy (revocation_map);
}

References core_api, free_entry(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CORE_disconnect(), GNUNET_DISK_file_close(), GNUNET_NO, GNUNET_SETU_destroy(), GNUNET_SETU_listen_cancel(), GNUNET_STATISTICS_destroy(), peers, revocation_db, revocation_map, revocation_set, revocation_union_listen_handle, and stats.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

core_init()

static void core_init ( void *  cls, const struct GNUNET_PeerIdentity *  identity  )

static

Called on core init/fail.

Parameters

cls	service closure
identity	the public identity of this peer

Definition at line 788 of file gnunet-service-revocation.c.

{
  if (NULL == identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection to core FAILED!\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  my_identity = *identity;
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), identity, and my_identity.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_revocation_union_request()

static void handle_revocation_union_request ( void *  cls, const struct GNUNET_PeerIdentity *  other_peer, const struct GNUNET_MessageHeader *  context_msg, struct GNUNET_SETU_Request *  request  )

static

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

If a listen error occurs, the 'request' is NULL.

Parameters

cls	closure
other_peer	the other peer
context_msg	message with application specific information from the other peer
request	request from the other peer (never NULL), use GNUNET_SETU_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, which sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 818 of file gnunet-service-revocation.c.

{
  struct PeerEntry *peer_entry;
 
  if (NULL == request)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received set exchange request from peer `%s'\n",
              GNUNET_i2s (other_peer));
  peer_entry = GNUNET_CONTAINER_multipeermap_get (peers,
                                                  other_peer);
  if (NULL == peer_entry)
  {
    peer_entry = new_peer_entry (other_peer);
  }
  if (NULL != peer_entry->so)
  {
    GNUNET_break_op (0);
    return;
  }
  peer_entry->so = GNUNET_SETU_accept (request,
                                       (struct GNUNET_SETU_Option[]) { { 0 } },
                                       &add_revocation,
                                       peer_entry);
  if (GNUNET_OK !=
      GNUNET_SETU_commit (peer_entry->so,
                          revocation_set))
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References add_revocation(), GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_SETU_accept(), GNUNET_SETU_commit(), new_peer_entry(), peers, request, revocation_set, and PeerEntry::so.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  c, struct GNUNET_SERVICE_Handle *  service  )

static

Handle network size estimate clients.

Parameters

cls	closure
server	the initialized server
c	configuration to use

Definition at line 867 of file gnunet-service-revocation.c.

{
  struct GNUNET_MQ_MessageHandler core_handlers[] = {
    GNUNET_MQ_hd_var_size (p2p_revoke,
                           GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE,
                           struct RevokeMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  char *fn;
  uint64_t left;
  struct RevokeMessage *rm;
  struct GNUNET_HashCode hc;
  const struct GNUNET_IDENTITY_PublicKey *pk;
 
  GNUNET_CRYPTO_hash ("revocation-set-union-application-id",
                      strlen ("revocation-set-union-application-id"),
                      &revocation_set_union_app_id);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (c,
                                               "REVOCATION",
                                               "DATABASE",
                                               &fn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "REVOCATION",
                               "DATABASE");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  cfg = c;
  revocation_map = GNUNET_CONTAINER_multihashmap_create (16,
                                                         GNUNET_NO);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "REVOCATION",
                                             "WORKBITS",
                                             &revocation_work_required))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "REVOCATION",
                               "WORKBITS");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (fn);
    return;
  }
  if (revocation_work_required >= sizeof(struct GNUNET_HashCode) * 8)
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "REVOCATION",
                               "WORKBITS",
                               _ ("Value is too large.\n"));
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (fn);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg,
                                           "REVOCATION",
                                           "EPOCH_DURATION",
                                           &epoch_duration))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "REVOCATION",
                               "EPOCH_DURATION");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (fn);
    return;
  }
 
  revocation_set = GNUNET_SETU_create (cfg);
  revocation_union_listen_handle
    = GNUNET_SETU_listen (cfg,
                          &revocation_set_union_app_id,
                          &handle_revocation_union_request,
                          NULL);
  revocation_db = GNUNET_DISK_file_open (fn,
                                         GNUNET_DISK_OPEN_READWRITE
                                         | GNUNET_DISK_OPEN_CREATE,
                                         GNUNET_DISK_PERM_USER_READ
                                         | GNUNET_DISK_PERM_USER_WRITE
                                         | GNUNET_DISK_PERM_GROUP_READ
                                         | GNUNET_DISK_PERM_OTHER_READ);
  if (NULL == revocation_db)
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "REVOCATION",
                               "DATABASE",
                               _ ("Could not open revocation database file!"));
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (fn);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (fn, &left, GNUNET_YES, GNUNET_YES))
    left = 0;
  while (left > sizeof(struct RevokeMessage))
  {
    rm = GNUNET_new (struct RevokeMessage);
    if (sizeof(struct RevokeMessage) !=
        GNUNET_DISK_file_read (revocation_db,
                               rm,
                               sizeof(struct RevokeMessage)))
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "read",
                                fn);
      GNUNET_free (rm);
      GNUNET_SCHEDULER_shutdown ();
      GNUNET_free (fn);
      return;
    }
    struct GNUNET_REVOCATION_PowP *pow = (struct
                                          GNUNET_REVOCATION_PowP *) &rm[1];
    ssize_t ksize;
    pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
    ksize = GNUNET_IDENTITY_public_key_get_length (pk);
    if (0 > ksize)
    {
      GNUNET_break_op (0);
      GNUNET_free (rm);
      GNUNET_free (fn);
      return;
    }
    GNUNET_CRYPTO_hash (pk,
                        ksize,
                        &hc);
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap_put (revocation_map,
                                                     &hc,
                                                     rm,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  GNUNET_free (fn);
 
  peers = GNUNET_CONTAINER_multipeermap_create (128,
                                                GNUNET_YES);
  /* Connect to core service and register core handlers */
  core_api = GNUNET_CORE_connect (cfg,    /* Main configuration */
                                  NULL,       /* Closure passed to functions */
                                  &core_init,    /* Call core_init once connected */
                                  &handle_core_connect,  /* Handle connects */
                                  &handle_core_disconnect,       /* Handle disconnects */
                                  core_handlers);        /* Register these handlers */
  if (NULL == core_api)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  stats = GNUNET_STATISTICS_create ("revocation",
                                    cfg);
}

References _, cfg, core_api, core_init(), epoch_duration, GNUNET_break, GNUNET_break_op, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_CRYPTO_hash(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_size(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_public_key_get_length(), GNUNET_log_config_invalid(), GNUNET_log_config_missing(), GNUNET_log_strerror_file, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SETU_create(), GNUNET_SETU_listen(), GNUNET_STATISTICS_create(), GNUNET_YES, handle_core_connect(), handle_core_disconnect(), handle_revocation_union_request(), peers, pk, GNUNET_REVOCATION_PowP::pow, revocation_db, revocation_map, revocation_set, revocation_set_union_app_id, revocation_union_listen_handle, revocation_work_required, shutdown_task(), and stats.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"revocation"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(query_message, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, struct QueryMessage, NULL)	,
		GNUNET_MQ_hd_var_size(revoke_message, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, struct RevokeMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

revocation_set

struct GNUNET_SETU_Handle* revocation_set

static

Set from all revocations known to us.

Definition at line 83 of file gnunet-service-revocation.c.

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

revocation_map

struct GNUNET_CONTAINER_MultiHashMap* revocation_map

static

Hash map with all revoked keys, maps the hash of the public key to the respective struct RevokeMessage.

Definition at line 89 of file gnunet-service-revocation.c.

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

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our current configuration.

Definition at line 94 of file gnunet-service-revocation.c.

Referenced by run().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle to the statistics service.

Definition at line 99 of file gnunet-service-revocation.c.

Referenced by add_revocation(), handle_core_connect(), handle_core_disconnect(), run(), and shutdown_task().

core_api

struct GNUNET_CORE_Handle* core_api

static

Handle to the core service (for flooding)

Definition at line 104 of file gnunet-service-revocation.c.

Referenced by run(), and shutdown_task().

peers

struct GNUNET_CONTAINER_MultiPeerMap* peers

static

Map of all connected peers.

Definition at line 109 of file gnunet-service-revocation.c.

Referenced by handle_core_connect(), handle_core_disconnect(), handle_revocation_union_request(), new_peer_entry(), run(), and shutdown_task().

my_identity

struct GNUNET_PeerIdentity my_identity

static

The peer identity of this peer.

Definition at line 109 of file gnunet-service-revocation.c.

Referenced by core_init(), handle_core_connect(), and handle_core_disconnect().

revocation_db

struct GNUNET_DISK_FileHandle* revocation_db

static

File handle for the revocation database.

Definition at line 119 of file gnunet-service-revocation.c.

Referenced by run(), and shutdown_task().

revocation_union_listen_handle

struct GNUNET_SETU_ListenHandle* revocation_union_listen_handle

static

Handle for us listening to incoming revocation set union requests.

Definition at line 124 of file gnunet-service-revocation.c.

Referenced by run(), and shutdown_task().

revocation_work_required

unsigned long long revocation_work_required

static

Amount of work required (W-bit collisions) for REVOCATION proofs, in collision-bits.

Definition at line 129 of file gnunet-service-revocation.c.

Referenced by run().

epoch_duration

struct GNUNET_TIME_Relative epoch_duration

static

Length of an expiration expoch.

Definition at line 129 of file gnunet-service-revocation.c.

Referenced by run().

revocation_set_union_app_id

struct GNUNET_HashCode revocation_set_union_app_id

static

Our application ID for set union operations.

Must be the same for all (compatible) peers.

Definition at line 129 of file gnunet-service-revocation.c.

Referenced by run(), and transmit_task_cb().