GNUnet  0.11.x
revocation_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2013, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
25 #include "platform.h"
27 #include "gnunet_signatures.h"
28 #include "gnunet_protocols.h"
29 #include "revocation.h"
30 #include <inttypes.h>
31 
36 {
41 
46 
50  void *func_cls;
51 };
52 
53 
58 struct BestPow
59 {
63  uint64_t pow;
64 
68  unsigned int bits;
69 };
70 
71 
77 {
81  struct BestPow best[POW_COUNT];
82 
87 
91  uint64_t current_pow;
92 
97  unsigned int epochs;
98 
102  unsigned int difficulty;
103 
104 };
105 
106 static struct GNUNET_CRYPTO_PowSalt salt = { "GnsRevocationPow" };
107 
117 static void
119  enum GNUNET_MQ_Error error)
120 {
121  struct GNUNET_REVOCATION_Query *q = cls;
122 
124  "Revocation query MQ error\n");
125  q->func (q->func_cls,
126  GNUNET_SYSERR);
128 }
129 
130 
137 static void
139  const struct QueryResponseMessage *qrm)
140 {
141  struct GNUNET_REVOCATION_Query *q = cls;
142 
144  "Revocation query result: %d\n",
145  (uint32_t) ntohl (qrm->is_valid));
146  q->func (q->func_cls,
147  ntohl (qrm->is_valid));
149 }
150 
151 
163  const struct GNUNET_CRYPTO_EcdsaPublicKey *key,
165  void *func_cls)
166 {
167  struct GNUNET_REVOCATION_Query *q
169  struct GNUNET_MQ_MessageHandler handlers[] = {
170  GNUNET_MQ_hd_fixed_size (revocation_query_response,
172  struct QueryResponseMessage,
173  q),
175  };
176  struct QueryMessage *qm;
177  struct GNUNET_MQ_Envelope *env;
178 
179  q->mq = GNUNET_CLIENT_connect (cfg,
180  "revocation",
181  handlers,
183  q);
184  if (NULL == q->mq)
185  {
186  GNUNET_free (q);
187  return NULL;
188  }
189  q->func = func;
190  q->func_cls = func_cls;
191  env = GNUNET_MQ_msg (qm,
193  qm->reserved = htonl (0);
194  qm->key = *key;
195  GNUNET_MQ_send (q->mq,
196  env);
197  return q;
198 }
199 
200 
206 void
208 {
209  if (NULL != q->mq)
210  {
211  GNUNET_MQ_destroy (q->mq);
212  q->mq = NULL;
213  }
214  GNUNET_free (q);
215 }
216 
217 
222 {
227 
232 
236  void *func_cls;
237 };
238 
239 
249 static void
251  enum GNUNET_MQ_Error error)
252 {
253  struct GNUNET_REVOCATION_Handle *h = cls;
254 
256  "Revocation MQ error\n");
257  h->func (h->func_cls,
258  GNUNET_SYSERR);
260 }
261 
262 
269 static void
271  const struct RevocationResponseMessage *rrm)
272 {
273  struct GNUNET_REVOCATION_Handle *h = cls;
274 
276  "Revocation transmission result: %d\n",
277  (uint32_t) ntohl (rrm->is_valid));
278  h->func (h->func_cls,
279  ntohl (rrm->is_valid));
281 }
282 
283 
302  const struct GNUNET_REVOCATION_PowP *pow,
304  void *func_cls)
305 {
308  struct GNUNET_MQ_MessageHandler handlers[] = {
309  GNUNET_MQ_hd_fixed_size (revocation_response,
312  h),
314  };
315  unsigned long long matching_bits;
316  struct GNUNET_TIME_Relative epoch_duration;
317  struct RevokeMessage *rm;
318  struct GNUNET_MQ_Envelope *env;
319 
320  if ((GNUNET_OK !=
322  "REVOCATION",
323  "WORKBITS",
324  &matching_bits)))
325  {
326  GNUNET_break (0);
327  GNUNET_free (h);
328  return NULL;
329  }
330  if ((GNUNET_OK !=
332  "REVOCATION",
333  "EPOCH_DURATION",
334  &epoch_duration)))
335  {
336  GNUNET_break (0);
337  GNUNET_free (h);
338  return NULL;
339  }
341  (unsigned int) matching_bits,
342  epoch_duration))
343  {
344  GNUNET_break (0);
345  GNUNET_free (h);
346  return NULL;
347  }
348 
349 
350  h->mq = GNUNET_CLIENT_connect (cfg,
351  "revocation",
352  handlers,
354  h);
355  if (NULL == h->mq)
356  {
357  GNUNET_free (h);
358  return NULL;
359  }
360  h->func = func;
361  h->func_cls = func_cls;
362  env = GNUNET_MQ_msg (rm,
364  rm->reserved = htonl (0);
365  rm->proof_of_work = *pow;
366  GNUNET_MQ_send (h->mq,
367  env);
368  return h;
369 }
370 
371 
377 void
379 {
380  if (NULL != h->mq)
381  {
382  GNUNET_MQ_destroy (h->mq);
383  h->mq = NULL;
384  }
385  GNUNET_free (h);
386 }
387 
388 
395 static unsigned int
397 {
398  unsigned int hash_count;
399  hash_count = 0;
400  while ((0 == GNUNET_CRYPTO_hash_get_bit_ltr (hash, hash_count)))
401  hash_count++;
402  return hash_count;
403 }
404 
405 
412 static unsigned int
414 {
415  double sum = 0.0;
416  for (unsigned int j = 0; j<POW_COUNT; j++)
417  sum += ph->best[j].bits;
418  double avg = sum / POW_COUNT;
419  return avg;
420 }
421 
422 
433  unsigned int difficulty,
435 {
436  char buf[sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
437  + sizeof (struct GNUNET_TIME_AbsoluteNBO)
438  + sizeof (uint64_t)] GNUNET_ALIGN;
440  struct GNUNET_HashCode result;
441  struct GNUNET_TIME_Absolute ts;
442  struct GNUNET_TIME_Absolute exp;
443  struct GNUNET_TIME_Relative ttl;
444  struct GNUNET_TIME_Relative buffer;
445  unsigned int score = 0;
446  unsigned int tmp_score = 0;
447  unsigned int epochs;
448  uint64_t pow_val;
449 
453  spurp.key = pow->key;
454  spurp.timestamp = pow->timestamp;
456  spurp.purpose.size = htonl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
457  + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
458  + sizeof (struct GNUNET_TIME_AbsoluteNBO));
459  if (GNUNET_OK !=
461  &spurp.purpose,
462  &pow->signature,
463  &pow->key))
464  {
466  "Proof of work signature invalid!\n");
467  return GNUNET_NO;
468  }
469 
473  for (unsigned int i = 0; i < POW_COUNT - 1; i++)
474  {
475  if (GNUNET_ntohll (pow->pow[i]) >= GNUNET_ntohll (pow->pow[i + 1]))
476  return GNUNET_NO;
477  }
478  GNUNET_memcpy (&buf[sizeof(uint64_t)],
479  &pow->timestamp,
480  sizeof (uint64_t));
481  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
482  &pow->key,
483  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey));
484  for (unsigned int i = 0; i < POW_COUNT; i++)
485  {
486  pow_val = GNUNET_ntohll (pow->pow[i]);
487  GNUNET_memcpy (buf, &pow->pow[i], sizeof(uint64_t));
488  GNUNET_CRYPTO_pow_hash (&salt,
489  buf,
490  sizeof(buf),
491  &result);
492  tmp_score = count_leading_zeroes (&result);
494  "Score %u with %" PRIu64 " (#%u)\n",
495  tmp_score, pow_val, i);
496 
497  score += tmp_score;
498 
499  }
500  score = score / POW_COUNT;
501  if (score < difficulty)
502  return GNUNET_NO;
503  epochs = score - difficulty;
504 
509  ttl = GNUNET_TIME_relative_multiply (epoch_duration,
510  epochs);
514  buffer = GNUNET_TIME_relative_divide (epoch_duration,
515  10);
516  exp = GNUNET_TIME_absolute_add (ts, ttl);
517  exp = GNUNET_TIME_absolute_add (exp,
518  buffer);
519 
521  return GNUNET_NO; /* Not yet valid. */
522  /* Revert to actual start time */
523  ts = GNUNET_TIME_absolute_add (ts,
524  buffer);
525 
526  if (0 == GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
527  return GNUNET_NO; /* expired */
528  return GNUNET_YES;
529 }
530 
531 
538 void
540  struct GNUNET_REVOCATION_PowP *pow)
541 {
544 
551 
553  rp.timestamp = pow->timestamp;
555  rp.purpose.size = htonl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
556  + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
557  + sizeof (struct GNUNET_TIME_AbsoluteNBO));
559  rp.key = pow->key;
562  &rp.purpose,
563  &pow->signature));
564 }
565 
566 
578  int epochs,
579  unsigned int difficulty)
580 {
582  struct GNUNET_TIME_Relative ttl;
583 
584 
586  pc->pow = pow;
588  epochs);
589  pc->pow->ttl = GNUNET_TIME_relative_hton (ttl);
591  UINT64_MAX);
592  pc->difficulty = difficulty;
593  pc->epochs = epochs;
594  return pc;
595 }
596 
597 
605 static int
606 cmp_pow_value (const void *a, const void *b)
607 {
608  return (GNUNET_ntohll (*(uint64_t*) a) - GNUNET_ntohll (*(uint64_t*) b));
609 }
610 
611 
624 {
625  char buf[sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
626  + sizeof (uint64_t)
627  + sizeof (uint64_t)] GNUNET_ALIGN;
628  struct GNUNET_HashCode result;
629  unsigned int zeros;
630  int ret;
631  uint64_t pow_nbo;
632 
633  pc->current_pow++;
634 
638  for (unsigned int i = 0; i < POW_COUNT; i++)
639  if (pc->current_pow == pc->best[i].pow)
640  return GNUNET_NO;
641  pow_nbo = GNUNET_htonll (pc->current_pow);
642  GNUNET_memcpy (buf, &pow_nbo, sizeof(uint64_t));
643  GNUNET_memcpy (&buf[sizeof(uint64_t)],
644  &pc->pow->timestamp,
645  sizeof (uint64_t));
646  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
647  &pc->pow->key,
648  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey));
649  GNUNET_CRYPTO_pow_hash (&salt,
650  buf,
651  sizeof(buf),
652  &result);
653  zeros = count_leading_zeroes (&result);
654  for (unsigned int i = 0; i < POW_COUNT; i++)
655  {
656  if (pc->best[i].bits < zeros)
657  {
658  pc->best[i].bits = zeros;
659  pc->best[i].pow = pc->current_pow;
660  pc->pow->pow[i] = pow_nbo;
662  "New best score %u with %" PRIu64 " (#%u)\n",
663  zeros, pc->current_pow, i);
664 
665  break;
666  }
667  }
668  ret = calculate_score (pc) >= pc->difficulty + pc->epochs ? GNUNET_YES :
669  GNUNET_NO;
670  if (GNUNET_YES == ret)
671  {
672  /* Sort POWs) */
673  qsort (pc->pow->pow, POW_COUNT, sizeof (uint64_t), &cmp_pow_value);
674  }
675  return ret;
676 }
677 
678 
686 void
688 {
689  GNUNET_free (pc);
690 }
691 
692 
693 /* end of revocation_api.c */
#define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY
Client to service: was this key revoked?
struct GNUNET_REVOCATION_PowP proof_of_work
Number that causes a hash collision with the public_key.
Definition: revocation.h:95
void GNUNET_REVOCATION_pow_init(const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, struct GNUNET_REVOCATION_PowP *pow)
Initializes a fresh PoW computation.
static unsigned int epochs
-e option.
void GNUNET_REVOCATION_query_cancel(struct GNUNET_REVOCATION_Query *q)
Cancel key revocation check.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Subtract a given relative duration from the given start time.
Definition: time.c:422
static unsigned int calculate_score(const struct GNUNET_REVOCATION_PowCalculationHandle *ph)
Calculate the average zeros in the pows.
int GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint64_t rel_value_us
The actual value.
struct GNUNET_MQ_Handle * mq
Message queue to the service.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the revocation.
struct GNUNET_CRYPTO_EcdsaPublicKey key
The revoked public key.
enum GNUNET_GenericReturnValue GNUNET_REVOCATION_pow_round(struct GNUNET_REVOCATION_PowCalculationHandle *pc)
Calculate a key revocation valid for broadcasting for a number of epochs.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1063
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
static void revocation_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
uint64_t current_pow
The current nonce to try.
GNUNET_MQ_Error
Error codes for the queue.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
struct GNUNET_MQ_Handle * mq
Message queue to the service.
#define POW_COUNT
The proof-of-work narrowing factor.
Struct for a proof of work as part of the revocation.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_ATS_PerformanceHandle * ph
ATS performance handle used.
Definition: gnunet-ats.c:116
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:83
struct BestPow best[POW_COUNT]
Current set of found PoWs.
The signature object we use for the PoW.
uint64_t pow
PoW nonce.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:395
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Private ECC key encoded for transmission.
Query key revocation status.
Definition: revocation.h:37
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
void GNUNET_REVOCATION_pow_stop(struct GNUNET_REVOCATION_PowCalculationHandle *pc)
Stop a PoW calculation.
#define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE
Client to service OR peer-to-peer: revoke this key!
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static unsigned int count_leading_zeroes(const struct GNUNET_HashCode *hash)
Count the leading zeroes in hash.
static struct GNUNET_TIME_Relative epoch_duration
Epoch length.
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
void * func_cls
Closure for func.
#define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE
Service to client: answer if key was revoked!
static int cmp_pow_value(const void *a, const void *b)
Comparison function for quicksort.
Revoke key.
Definition: revocation.h:80
Key revocation response.
Definition: revocation.h:59
static void handle_revocation_response(void *cls, const struct RevocationResponseMessage *rrm)
Handle response to our revocation query.
#define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE
Service to client: revocation confirmed.
messages for key revocation
unsigned int difficulty
The difficulty (leading zeros) to achieve.
static char buf[2048]
struct GNUNET_REVOCATION_PowP * pow
The final PoW result data structure.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
void * func_cls
Closure for func.
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
A 512-bit hashcode.
static void handle_revocation_query_response(void *cls, const struct QueryResponseMessage *qrm)
Handle response to our revocation query.
Message handler for a specific message type.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
uint64_t pow[32]
The PoWs.
struct GNUNET_CRYPTO_EcdsaSignature signature
The signature.
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
void GNUNET_CRYPTO_pow_hash(const struct GNUNET_CRYPTO_PowSalt *salt, const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
Calculate the &#39;proof-of-work&#39; hash (an expensive hash).
Definition: crypto_pow.c:41
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
uint32_t is_valid
GNUNET_NO if revoked, GNUNET_YES if valid.
Definition: revocation.h:69
#define GNUNET_SIGNATURE_PURPOSE_REVOCATION
Signature for confirming a key revocation.
struct GNUNET_HashCode key
The key used in the DHT.
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:176
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:625
uint32_t reserved
For alignment.
Definition: revocation.h:47
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Value for a salt for GNUNET_CRYPTO_pow_hash().
unsigned int bits
Corresponding zero bits in hash.
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...
Handle for the key revocation query.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the revocation.
int GNUNET_CRYPTO_ecdsa_sign_(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
ECDSA Sign a given block.
Definition: crypto_ecc.c:645
Key revocation response.
Definition: revocation.h:102
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.
void(* GNUNET_REVOCATION_Callback)(void *cls, enum GNUNET_GenericReturnValue is_valid)
Callback to call with the result of a key revocation query.
Handle to a message queue.
Definition: mq.c:85
int GNUNET_CRYPTO_ecdsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition: crypto_ecc.c:745
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
struct GNUNET_CRYPTO_EcdsaPublicKey key
Key to check.
Definition: revocation.h:52
configuration data
Definition: configuration.c:84
#define GNUNET_TIME_UNIT_WEEKS
One week.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static void query_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
#define GNUNET_TIME_UNIT_YEARS
One year (365 days).
#define GNUNET_log(kind,...)
struct GNUNET_REVOCATION_Query * GNUNET_REVOCATION_query(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_EcdsaPublicKey *key, GNUNET_REVOCATION_Callback func, void *func_cls)
Check if a key was revoked.
static struct GNUNET_CRYPTO_PowSalt salt
Handle for the key revocation operation.
int GNUNET_CRYPTO_hash_get_bit_ltr(const struct GNUNET_HashCode *code, unsigned int bit)
Obtain a bit from a hashcode.
Definition: crypto_hash.c:252
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
GNUNET_REVOCATION_Callback func
Function to call with the result.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:527
Time for absolute times used by GNUnet, in microseconds.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
GNUNET_REVOCATION_Callback func
Function to call once we are done.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
The handle to a PoW calculation.
uint32_t is_valid
GNUNET_NO if revocation failed for internal reasons (e.g.
Definition: revocation.h:113
void GNUNET_REVOCATION_revoke_cancel(struct GNUNET_REVOCATION_Handle *h)
Cancel key revocation.
static unsigned long long matching_bits
Number of matching bits required for revocation.
unsigned int epochs
Epochs how long the PoW should be valid.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
struct GNUNET_CRYPTO_EcdsaPublicKey key
The revoked public key.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
The signature purpose.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Helper struct that holds a found pow nonce and the corresponding number of leading zeroes...
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
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.
uint32_t reserved
For alignment.
Definition: revocation.h:90