key revocation service More...

#include "gnunet_common.h"
#include "gnunet_pils_service.h"
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_dht_block_types.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_core_service.h"
#include "gnunet_setu_service.h"
#include "revocation.h"
#include <gcrypt.h>

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

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.

static enum GNUNET_GenericReturnValue	verify_revoke_message (const struct RevokeMessage *rm)
	An revoke message has been received, check that it is well-formed.

static void *	client_connect_cb (void cls, struct GNUNET_SERVICE_Client client, struct GNUNET_MQ_Handle *mq)
	Handle client connecting to the service.

static void	client_disconnect_cb (void cls, struct GNUNET_SERVICE_Client client, void *app_cls)
	Handle client connecting to the service.

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.

static enum GNUNET_GenericReturnValue	do_flood (void cls, const struct GNUNET_PeerIdentity target, void *value)
	Flood the given revocation message to all neighbours.

static enum GNUNET_GenericReturnValue	publicize_rm (const struct RevokeMessage *rm)
	Publicize revocation message.

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.

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.

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.

static void	transmit_task_cb (void *cls)
	The timeout for performing the set union has expired, run the set operation on the revocation certificates.

static void *	handle_core_connect (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a peer connects.

static void	handle_core_disconnect (void cls, const struct GNUNET_PeerIdentity peer, void *internal_cls)
	Method called whenever a peer disconnects.

static int	free_entry (void cls, const struct GNUNET_HashCode key, void *value)
	Free all values in a hash map.

static void	shutdown_task (void *cls)
	Task run during shutdown.

static void	core_init (void cls, const struct GNUNET_PeerIdentity identity)
	Called on core init/fail.

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.

static void	run (void cls, const struct GNUNET_CONFIGURATION_Handle c, struct GNUNET_SERVICE_Handle *service)
	Handle network size estimate clients.

	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "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.

Variables
static struct GNUNET_SETU_Handle *	revocation_set
	Set from all revocations known to us.

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`.

static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our current configuration.

static struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service.

static struct GNUNET_CORE_Handle *	core_api
	Handle to the core service (for flooding)

static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	Map of all connected peers.

static struct GNUNET_PILS_Handle *	pils
	Handle to the pils service.

static struct GNUNET_DISK_FileHandle *	revocation_db
	File handle for the revocation database.

static struct GNUNET_SETU_ListenHandle *	revocation_union_listen_handle
	Handle for us listening to incoming revocation set union requests.

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

static struct GNUNET_TIME_Relative	epoch_duration
	Length of an expiration expoch.

static struct GNUNET_HashCode	revocation_set_union_app_id
	Our application ID for set union operations.

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 149 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, 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 172 of file gnunet-service-revocation.c.

{
  const struct GNUNET_GNSRECORD_PowP *pow
    = (const struct GNUNET_GNSRECORD_PowP *) &rm[1];
 
  if (GNUNET_YES !=
      GNUNET_GNSRECORD_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;
}

References epoch_duration, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_check_pow(), GNUNET_log, GNUNET_NO, GNUNET_YES, GNUNET_GNSRECORD_PowP::pow, and revocation_work_required.

Referenced by publicize_rm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ client_connect_cb()

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

static

Handle client connecting to the service.

Parameters

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

Returns: client

Definition at line 200 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 216 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_CRYPTO_BlindablePublicKey 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_CRYPTO_read_blindable_pk_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);
}

References env, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_read_blindable_pk_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), 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, and revocation_map.

Here is the call graph for this function:

◆ 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 300 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 GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, PeerEntry::mq, RevokeMessage::pow_size, and value.

Referenced by publicize_rm().

Here is the call graph for this function:

Here is the caller 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 339 of file gnunet-service-revocation.c.

{
  struct RevokeMessage *cp;
  struct GNUNET_HashCode hc;
  struct GNUNET_SETU_Element e;
  ssize_t pklen;
  const struct GNUNET_GNSRECORD_PowP *pow
    = (const struct GNUNET_GNSRECORD_PowP *) &rm[1];
  const struct GNUNET_CRYPTO_BlindablePublicKey *pk
    = (const struct GNUNET_CRYPTO_BlindablePublicKey *) &pow[1];
 
  pklen = GNUNET_CRYPTO_blindable_pk_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;
}

References GNUNET_SETU_Element::data, do_flood(), GNUNET_SETU_Element::element_type, GNUNET_BLOCK_TYPE_REVOCATION, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_copy_message(), GNUNET_CRYPTO_blindable_pk_get_length(), GNUNET_CRYPTO_hash(), GNUNET_DISK_file_sync(), GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_NO, GNUNET_OK, GNUNET_SETU_add_element(), GNUNET_SYSERR, GNUNET_YES, RevokeMessage::header, peers, pk, GNUNET_GNSRECORD_PowP::pow, revocation_db, revocation_map, revocation_set, GNUNET_MessageHeader::size, GNUNET_SETU_Element::size, and verify_revoke_message().

Referenced by handle_p2p_revoke(), and handle_revoke_message().

Here is the call graph for this function:

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,
		enum GNUNET_CORE_PeerClass	class
	)

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
class	class of the connecting peer

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HashCode my_identity_hash;
  struct PeerEntry *peer_entry;
  struct GNUNET_HashCode peer_hash;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (NULL != my_identity);
 
  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_identity_hash);
  GNUNET_CRYPTO_hash (peer,
                      sizeof(*peer),
                      &peer_hash);
  if (0 < GNUNET_CRYPTO_hash_cmp (&my_identity_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_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_SECONDS, mq, PeerEntry::mq, my_identity, new_peer_entry(), peers, pils, 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 686 of file gnunet-service-revocation.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct PeerEntry *peer_entry = internal_cls;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (NULL != my_identity);
 
  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_PILS_get_identity(), GNUNET_SCHEDULER_cancel(), GNUNET_SETU_operation_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, my_identity, peers, pils, 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 733 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 748 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 != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = 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_PILS_disconnect(), GNUNET_SETU_destroy(), GNUNET_SETU_listen_cancel(), GNUNET_STATISTICS_destroy(), peers, pils, revocation_db, revocation_map, revocation_set, revocation_union_listen_handle, and stats.

Here is the call 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 799 of file gnunet-service-revocation.c.

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

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), and 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 828 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 877 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;
  ssize_t ksize;
  struct RevokeMessage *rm;
  struct GNUNET_HashCode hc;
  struct GNUNET_GNSRECORD_PowP *pow;
  const struct GNUNET_CRYPTO_BlindablePublicKey *pk;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_REVOCATION,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  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;
    }
    pow = (struct GNUNET_GNSRECORD_PowP *) &rm[1];
    pk = (const struct GNUNET_CRYPTO_BlindablePublicKey *) &pow[1];
    ksize = GNUNET_CRYPTO_blindable_pk_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);
  pils = GNUNET_PILS_connect (cfg, NULL, NULL);
  /* 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 */
                                  &service_info);
  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_CORE_SERVICE_REVOCATION, GNUNET_CRYPTO_blindable_pk_get_length(), 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_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_PILS_connect(), 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, pils, pk, GNUNET_GNSRECORD_PowP::pow, revocation_db, revocation_map, revocation_set, revocation_set_union_app_id, revocation_union_listen_handle, revocation_work_required, GNUNET_CORE_ServiceInfo::service, shutdown_task, and stats.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"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()
	)