Revocation service

Perform and access key revocations. More...

Data Structures
struct	GNUNET_REVOCATION_PowP
	Struct for a proof of work as part of the revocation. More...
struct	GNUNET_REVOCATION_SignaturePurposePS
	The signature object we use for the PoW. More...

Macros
#define	GNUNET_REVOCATION_VERSION   0x00000001
	Version of the key revocation API. More...
#define	GNUNET_REVOCATION_MAX_PROOF_SIZE
	Maximum length of a revocation. More...
#define	POW_COUNT   32
	The proof-of-work narrowing factor. More...

Typedefs
typedef void(*	GNUNET_REVOCATION_Callback) (void *cls, enum GNUNET_GenericReturnValue is_valid)
	Callback to call with the result of a key revocation query. More...

Functions
struct GNUNET_REVOCATION_Query *	GNUNET_REVOCATION_query (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_IDENTITY_PublicKey *key, GNUNET_REVOCATION_Callback func, void *func_cls)
	Check if a key was revoked. More...
void	GNUNET_REVOCATION_query_cancel (struct GNUNET_REVOCATION_Query *q)
	Cancel key revocation check. More...
struct GNUNET_REVOCATION_Handle *	GNUNET_REVOCATION_revoke (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_REVOCATION_PowP *pow, GNUNET_REVOCATION_Callback func, void *func_cls)
	Perform key revocation. More...
void	GNUNET_REVOCATION_revoke_cancel (struct GNUNET_REVOCATION_Handle *h)
	Cancel key revocation. More...
enum GNUNET_GenericReturnValue	GNUNET_REVOCATION_check_pow (const struct GNUNET_REVOCATION_PowP *pow, unsigned int matching_bits, struct GNUNET_TIME_Relative epoch_duration)
	Check if the given proof-of-work is valid. More...
void	GNUNET_REVOCATION_pow_init (const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_REVOCATION_PowP *pow)
	Initializes a fresh PoW computation. More...
struct GNUNET_REVOCATION_PowCalculationHandle *	GNUNET_REVOCATION_pow_start (struct GNUNET_REVOCATION_PowP *pow, int epochs, unsigned int difficulty)
	Starts a proof-of-work calculation given the pow object as well as target epochs and difficulty. More...
enum GNUNET_GenericReturnValue	GNUNET_REVOCATION_pow_round (struct GNUNET_REVOCATION_PowCalculationHandle *pc)
	Calculate a single round in the key revocation PoW. More...
void	GNUNET_REVOCATION_pow_stop (struct GNUNET_REVOCATION_PowCalculationHandle *pc)
	Stop a PoW calculation. More...
size_t	GNUNET_REVOCATION_proof_get_size (const struct GNUNET_REVOCATION_PowP *pow)

Detailed Description

Perform and access key revocations.

See also

Documentation

Macro Definition Documentation

GNUNET_REVOCATION_VERSION

#define GNUNET_REVOCATION_VERSION   0x00000001

Version of the key revocation API.

Definition at line 53 of file gnunet_revocation_service.h.

GNUNET_REVOCATION_MAX_PROOF_SIZE

#define GNUNET_REVOCATION_MAX_PROOF_SIZE

Value:

sizeof(struct GNUNET_REVOCATION_PowP) +\
                                         sizeof(struct GNUNET_IDENTITY_PublicKey) +\
                                         1024

Maximum length of a revocation.

Definition at line 58 of file gnunet_revocation_service.h.

Referenced by ego_callback(), and run().

POW_COUNT

#define POW_COUNT   32

The proof-of-work narrowing factor.

The number of PoWs that are calculates as part of revocation.

Definition at line 66 of file gnunet_revocation_service.h.

Referenced by calculate_score(), GNUNET_REVOCATION_check_pow(), and GNUNET_REVOCATION_pow_round().

Typedef Documentation

GNUNET_REVOCATION_Callback

typedef void(* GNUNET_REVOCATION_Callback) (void *cls, enum GNUNET_GenericReturnValue is_valid)

Callback to call with the result of a key revocation query.

Parameters

cls	closure
is_valid	GNUNET_NO of the key is/was revoked, GNUNET_YES if the key is still valid, GNUNET_SYSERR if we had trouble querying the service

Definition at line 135 of file gnunet_revocation_service.h.

Function Documentation

GNUNET_REVOCATION_query()

struct GNUNET_REVOCATION_Query* GNUNET_REVOCATION_query	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_IDENTITY_PublicKey *	key,
		GNUNET_REVOCATION_Callback	func,
		void *	func_cls
	)

Check if a key was revoked.

Parameters

cfg	the configuration to use
key	key to check for revocation
func	function to call with the result of the check
func_cls	closure to pass to func

Returns

handle to use in GNUNET_REVOCATION_query_cancel to stop REVOCATION from invoking the callback

Definition at line 162 of file revocation_api.c.

References env, GNUNET_REVOCATION_Query::func, GNUNET_REVOCATION_Query::func_cls, GNUNET_CLIENT_connect(), GNUNET_free, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, key, QueryMessage::key, GNUNET_REVOCATION_Query::mq, q, query_mq_error_handler(), and QueryMessage::reserved.

Referenced by recursive_gns_resolution_revocation(), and run().

{
  struct GNUNET_REVOCATION_Query *q
    = GNUNET_new (struct GNUNET_REVOCATION_Query);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (revocation_query_response,
                             GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE,
                             struct QueryResponseMessage,
                             q),
    GNUNET_MQ_handler_end ()
  };
  struct QueryMessage *qm;
  struct GNUNET_MQ_Envelope *env;

  q->mq = GNUNET_CLIENT_connect (cfg,
                                 "revocation",
                                 handlers,
                                 &query_mq_error_handler,
                                 q);
  if (NULL == q->mq)
  {
    GNUNET_free (q);
    return NULL;
  }
  q->func = func;
  q->func_cls = func_cls;
  env = GNUNET_MQ_msg (qm,
                       GNUNET_MESSAGE_TYPE_REVOCATION_QUERY);
  qm->reserved = htonl (0);
  qm->key = *key;
  GNUNET_MQ_send (q->mq,
                  env);
  return q;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_query_cancel()

void GNUNET_REVOCATION_query_cancel

(

struct GNUNET_REVOCATION_Query *

q

)

Cancel key revocation check.

Parameters

q	query to cancel

Definition at line 207 of file revocation_api.c.

References GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_REVOCATION_Query::mq.

Referenced by do_shutdown(), GNS_resolver_lookup_cancel(), handle_revocation_query_response(), and query_mq_error_handler().

{
  if (NULL != q->mq)
  {
    GNUNET_MQ_destroy (q->mq);
    q->mq = NULL;
  }
  GNUNET_free (q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_revoke()

struct GNUNET_REVOCATION_Handle* GNUNET_REVOCATION_revoke	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_REVOCATION_PowP *	pow,
		GNUNET_REVOCATION_Callback	func,
		void *	func_cls
	)

Perform key revocation.

Parameters

cfg	the configuration to use
pow	proof of work to use (should have been created by iteratively calling GNUNET_REVOCATION_pow_round)
func	function to call with the result of the check (called with is_valid being GNUNET_NO if the revocation worked).
func_cls	closure to pass to func

Returns

handle to use in GNUNET_REVOCATION_revoke_cancel to stop REVOCATION from invoking the callback

Parameters

cfg	the configuration to use
key	public key of the key to revoke
sig	signature to use on the revocation (should have been created using #GNUNET_REVOCATION_sign_revocation).
ts	revocation timestamp
pow	proof of work to use (should have been created by iteratively calling GNUNET_REVOCATION_check_pow)
func	function to call with the result of the check (called with is_valid being GNUNET_NO if the revocation worked).
func_cls	closure to pass to func

Returns

handle to use in GNUNET_REVOCATION_revoke_cancel to stop REVOCATION from invoking the callback

Definition at line 301 of file revocation_api.c.

References env, GNUNET_REVOCATION_Query::func, GNUNET_REVOCATION_Handle::func, GNUNET_REVOCATION_Query::func_cls, GNUNET_REVOCATION_Handle::func_cls, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_free, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_REVOCATION_check_pow(), GNUNET_REVOCATION_proof_get_size(), GNUNET_YES, h, matching_bits, GNUNET_REVOCATION_Handle::mq, RevokeMessage::pow_size, and revocation_mq_error_handler().

Referenced by perform_revocation().

{
  struct GNUNET_REVOCATION_Handle *h
    = GNUNET_new (struct GNUNET_REVOCATION_Handle);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (revocation_response,
                             GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE,
                             struct RevocationResponseMessage,
                             h),
    GNUNET_MQ_handler_end ()
  };
  unsigned long long matching_bits;
  struct GNUNET_TIME_Relative epoch_duration;
  struct RevokeMessage *rm;
  struct GNUNET_MQ_Envelope *env;

  if ((GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (cfg,
                                              "REVOCATION",
                                              "WORKBITS",
                                              &matching_bits)))
  {
    GNUNET_break (0);
    GNUNET_free (h);
    return NULL;
  }
  if ((GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_time (cfg,
                                            "REVOCATION",
                                            "EPOCH_DURATION",
                                            &epoch_duration)))
  {
    GNUNET_break (0);
    GNUNET_free (h);
    return NULL;
  }
  if (GNUNET_YES != GNUNET_REVOCATION_check_pow (pow,
                                                 (unsigned int) matching_bits,
                                                 epoch_duration))
  {
    GNUNET_break (0);
    GNUNET_free (h);
    return NULL;
  }


  h->mq = GNUNET_CLIENT_connect (cfg,
                                 "revocation",
                                 handlers,
                                 &revocation_mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  h->func = func;
  h->func_cls = func_cls;
  size_t extra_len = GNUNET_REVOCATION_proof_get_size (pow);
  env = GNUNET_MQ_msg_extra (rm,
                             extra_len,
                             GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE);
  rm->pow_size = htonl (extra_len);
  memcpy (&rm[1], pow, extra_len);
  GNUNET_MQ_send (h->mq,
                  env);
  return h;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_revoke_cancel()

void GNUNET_REVOCATION_revoke_cancel

(

struct GNUNET_REVOCATION_Handle *

h

)

Cancel key revocation.

Parameters

h	operation to cancel

Definition at line 380 of file revocation_api.c.

References GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_REVOCATION_Handle::mq.

Referenced by do_shutdown(), handle_revocation_response(), and revocation_mq_error_handler().

{
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  GNUNET_free (h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_check_pow()

enum GNUNET_GenericReturnValue GNUNET_REVOCATION_check_pow	(	const struct GNUNET_REVOCATION_PowP *	pow,
		unsigned int	difficulty,
		struct GNUNET_TIME_Relative	epoch_duration
	)

Check if the given proof-of-work is valid.

Parameters

pow	proof of work
matching_bits	how many bits must match (configuration)
epoch_duration	length of single epoch in configuration

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Check if signature valid

First, check if PoW set is strictly monotically increasing

Check expiration

Extend by 10% for unsynchronized clocks

Definition at line 479 of file revocation_api.c.

References buf, check_signature(), count_leading_zeroes(), epochs, GNUNET_CRYPTO_pow_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_key_get_length(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_multiply(), GNUNET_YES, pk, GNUNET_REVOCATION_PowP::pow, POW_COUNT, and GNUNET_REVOCATION_PowP::timestamp.

Referenced by block_plugin_revocation_evaluate(), ego_callback(), GNUNET_REVOCATION_revoke(), run(), and verify_revoke_message().

{
  char buf[sizeof(struct GNUNET_IDENTITY_PublicKey)
           + sizeof (struct GNUNET_TIME_AbsoluteNBO)
           + sizeof (uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  struct GNUNET_TIME_Absolute ts;
  struct GNUNET_TIME_Absolute exp;
  struct GNUNET_TIME_Relative ttl;
  struct GNUNET_TIME_Relative buffer;
  unsigned int score = 0;
  unsigned int tmp_score = 0;
  unsigned int epochs;
  uint64_t pow_val;
  const struct GNUNET_IDENTITY_PublicKey *pk;

  pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];

  if (GNUNET_OK != check_signature (pow))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Proof of work signature invalid!\n");
    return GNUNET_SYSERR;
  }

  for (unsigned int i = 0; i < POW_COUNT - 1; i++)
  {
    if (GNUNET_ntohll (pow->pow[i]) >= GNUNET_ntohll (pow->pow[i + 1]))
      return GNUNET_NO;
  }
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 &pow->timestamp,
                 sizeof (uint64_t));
  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
                 pk,
                 GNUNET_IDENTITY_key_get_length (pk));
  for (unsigned int i = 0; i < POW_COUNT; i++)
  {
    pow_val = GNUNET_ntohll (pow->pow[i]);
    GNUNET_memcpy (buf, &pow->pow[i], sizeof(uint64_t));
    GNUNET_CRYPTO_pow_hash (&salt,
                            buf,
                            sizeof(buf),
                            &result);
    tmp_score = count_leading_zeroes (&result);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Score %u with %" PRIu64 " (#%u)\n",
                tmp_score, pow_val, i);

    score += tmp_score;

  }
  score = score / POW_COUNT;
  if (score < difficulty)
    return GNUNET_NO;
  epochs = score - difficulty;

  ts = GNUNET_TIME_absolute_ntoh (pow->timestamp);
  ttl = GNUNET_TIME_relative_multiply (epoch_duration,
                                       epochs);
  buffer = GNUNET_TIME_relative_divide (epoch_duration,
                                        10);
  exp = GNUNET_TIME_absolute_add (ts, ttl);
  exp = GNUNET_TIME_absolute_add (exp,
                                  buffer);

  if (0 != GNUNET_TIME_absolute_get_remaining (ts).rel_value_us)
    return GNUNET_NO; /* Not yet valid. */
  /* Revert to actual start time */
  ts = GNUNET_TIME_absolute_add (ts,
                                 buffer);

  if (0 == GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
    return GNUNET_NO; /* expired */
  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_pow_init()

void GNUNET_REVOCATION_pow_init	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		struct GNUNET_REVOCATION_PowP *	pow
	)

Initializes a fresh PoW computation.

Parameters

	key	the key to calculate the PoW for.
	pow	the pow object to work with in the calculation.
	key	the key to calculate the PoW for.
[out]	pow	starting point for PoW calculation (not yet valid)

Definition at line 630 of file revocation_api.c.

References GNUNET_assert, GNUNET_OK, and sign_pow().

Referenced by ego_callback(), and run().

{
  GNUNET_assert (GNUNET_OK == sign_pow (key, pow));
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_pow_start()

struct GNUNET_REVOCATION_PowCalculationHandle* GNUNET_REVOCATION_pow_start	(	struct GNUNET_REVOCATION_PowP *	pow,
		int	epochs,
		unsigned int	difficulty
	)

Starts a proof-of-work calculation given the pow object as well as target epochs and difficulty.

Parameters

pow	the PoW to based calculations on.
epochs	the number of epochs for which the PoW must be valid.
difficulty	the base difficulty of the PoW.

Returns

a handle for use in PoW rounds

Definition at line 647 of file revocation_api.c.

References epochs, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_new, GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_YEARS, and pc.

Referenced by ego_callback(), and run().

{
  struct GNUNET_REVOCATION_PowCalculationHandle *pc;
  struct GNUNET_TIME_Relative ttl;


  pc = GNUNET_new (struct GNUNET_REVOCATION_PowCalculationHandle);
  pc->pow = pow;
  ttl = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_YEARS,
                                       epochs);
  pc->pow->ttl = GNUNET_TIME_relative_hton (ttl);
  pc->current_pow = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                              UINT64_MAX);
  pc->difficulty = difficulty;
  pc->epochs = epochs;
  return pc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_pow_round()

enum GNUNET_GenericReturnValue GNUNET_REVOCATION_pow_round

(

struct GNUNET_REVOCATION_PowCalculationHandle *

pc

)

Calculate a single round in the key revocation PoW.

Parameters

pc	handle to the PoW, initially called with NULL.

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Calculate a single round in the key revocation PoW.

Parameters

pc	handle to the PoW, initially called with NULL.
epochs	number of epochs for which the revocation must be valid.
pow	current pow value to try
difficulty	current base difficulty to achieve

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Do not try duplicates

Definition at line 693 of file revocation_api.c.

References GNUNET_REVOCATION_PowCalculationHandle::best, BestPow::bits, buf, calculate_score(), cmp_pow_value(), count_leading_zeroes(), GNUNET_REVOCATION_PowCalculationHandle::current_pow, GNUNET_REVOCATION_PowCalculationHandle::difficulty, GNUNET_REVOCATION_PowCalculationHandle::epochs, GNUNET_CRYPTO_pow_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_IDENTITY_key_get_length(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_YES, pk, BestPow::pow, GNUNET_REVOCATION_PowCalculationHandle::pow, GNUNET_REVOCATION_PowP::pow, POW_COUNT, ret, and GNUNET_REVOCATION_PowP::timestamp.

Referenced by calculate_pow(), and run().

{
  char buf[sizeof(struct GNUNET_IDENTITY_PublicKey)
           + sizeof (uint64_t)
           + sizeof (uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  const struct GNUNET_IDENTITY_PublicKey *pk;
  unsigned int zeros;
  int ret;
  uint64_t pow_nbo;

  pc->current_pow++;
  pk = (const struct GNUNET_IDENTITY_PublicKey *) &(pc->pow[1]);

  for (unsigned int i = 0; i < POW_COUNT; i++)
    if (pc->current_pow == pc->best[i].pow)
      return GNUNET_NO;
  pow_nbo = GNUNET_htonll (pc->current_pow);
  GNUNET_memcpy (buf, &pow_nbo, sizeof(uint64_t));
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 &pc->pow->timestamp,
                 sizeof (uint64_t));
  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
                 pk,
                 GNUNET_IDENTITY_key_get_length (pk));
  GNUNET_CRYPTO_pow_hash (&salt,
                          buf,
                          sizeof(buf),
                          &result);
  zeros = count_leading_zeroes (&result);
  for (unsigned int i = 0; i < POW_COUNT; i++)
  {
    if (pc->best[i].bits < zeros)
    {
      pc->best[i].bits = zeros;
      pc->best[i].pow = pc->current_pow;
      pc->pow->pow[i] = pow_nbo;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "New best score %u with %" PRIu64 " (#%u)\n",
                  zeros, pc->current_pow, i);

      break;
    }
  }
  ret = calculate_score (pc) >= pc->difficulty + pc->epochs ? GNUNET_YES :
        GNUNET_NO;
  if (GNUNET_YES == ret)
  {
    /* Sort POWs) */
    qsort (pc->pow->pow, POW_COUNT, sizeof (uint64_t), &cmp_pow_value);
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_REVOCATION_pow_stop()

void GNUNET_REVOCATION_pow_stop

(

struct GNUNET_REVOCATION_PowCalculationHandle *

pc

)

Stop a PoW calculation.

Parameters

pc	the calculation to clean up

Returns

GNUNET_YES if pow valid, GNUNET_NO if pow was set but is not valid

Definition at line 759 of file revocation_api.c.

References GNUNET_free.

Referenced by calculate_pow_shutdown().

{
  GNUNET_free (pc);
}

Here is the caller graph for this function:

GNUNET_REVOCATION_proof_get_size()

size_t GNUNET_REVOCATION_proof_get_size

(

const struct GNUNET_REVOCATION_PowP *

pow

)

Definition at line 766 of file revocation_api.c.

References GNUNET_IDENTITY_key_get_length(), GNUNET_IDENTITY_signature_get_length(), pk, and size.

Referenced by calculate_pow(), GNUNET_REVOCATION_revoke(), run(), and sync_pow().

{
  size_t size;
  size_t ksize;
  const struct GNUNET_IDENTITY_PublicKey *pk;
  const struct GNUNET_IDENTITY_Signature *sig;

  size = sizeof (struct GNUNET_REVOCATION_PowP);
  pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
  ksize = GNUNET_IDENTITY_key_get_length (pk);
  size += ksize;
  sig = (struct GNUNET_IDENTITY_Signature *) ((char*) &pow[1] + ksize);
  size += GNUNET_IDENTITY_signature_get_length (sig);
  return size;
}

Here is the call graph for this function:

Here is the caller graph for this function: