GNUnet  0.20.0
gnunet-gnsrecord-tvg.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2020 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  */
20 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_signatures.h"
29 #include "gnunet_gns_service.h"
30 #include "gnunet_gnsrecord_lib.h"
31 #include "gnunet_testing_lib.h"
32 #include "gnsrecord_crypto.h"
33 #include <inttypes.h>
34 
35 
36 static char *d_pkey =
37  "50d7b652a4efeadff37396909785e5952171a02178c8e7d450fa907925fafd98";
38 
39 static char *d_edkey =
40  "5af7020ee19160328832352bbc6a68a8d71a7cbe1b929969a7c66d415a0d8f65";
41 
42 
43 static int
44 parsehex (char *src, char *dst, size_t dstlen, int invert)
45 {
46  char *line = src;
47  char *data = line;
48  int off;
49  int read_byte;
50  int data_len = 0;
51 
52  while (sscanf (data, " %02x%n", &read_byte, &off) == 1)
53  {
54  if (invert)
55  dst[dstlen - 1 - data_len++] = read_byte;
56  else
57  dst[data_len++] = read_byte;
58  data += off;
59  }
60  return data_len;
61 }
62 
63 
64 static void
66  size_t buf_len,
67  int fold,
68  int in_be)
69 {
70  int i;
71 
72  for (i = 0; i < buf_len; i++)
73  {
74  if (0 != i)
75  {
76  if ((0 != fold) && (i % fold == 0))
77  printf ("\n ");
78  else
79  printf (" ");
80  }
81  else
82  {
83  printf (" ");
84  }
85  if (in_be)
86  printf ("%02x", ((unsigned char*) buf)[buf_len - 1 - i]);
87  else
88  printf ("%02x", ((unsigned char*) buf)[i]);
89  }
90  printf ("\n");
91 }
92 
93 
94 static void
96  size_t buf_len,
97  int fold)
98 {
99  print_bytes_ (buf, buf_len, fold, 0);
100 }
101 
102 
103 static void
105 {
106  struct GNUNET_TIME_Relative rt;
107  struct GNUNET_TIME_Absolute at;
108  uint16_t flags = htons (rd->flags);
109  uint64_t abs_nbo = GNUNET_htonll (rd->expiration_time);
110  uint16_t size_nbo = htons (rd->data_size);
111  uint32_t type_nbo = htonl (rd->record_type);
112  at.abs_value_us = GNUNET_ntohll (abs_nbo);
114  {
117  abs_nbo = GNUNET_htonll (at.abs_value_us);
118  }
119  printf (" EXPIRATION: %" PRIu64 " us\n", rd->expiration_time);
120  print_bytes (&abs_nbo, sizeof (abs_nbo), 8);
121  printf ("\n DATA_SIZE:\n");
122  print_bytes (&size_nbo, sizeof (size_nbo), 8);
123  printf ("\n TYPE:\n");
124  print_bytes (&type_nbo, sizeof (type_nbo), 8);
125  printf ("\n FLAGS: ");
126  print_bytes ((void*) &flags, sizeof (flags), 8);
127  printf ("\n");
128  fprintf (stdout,
129  " DATA:\n");
130  print_bytes ((char*) rd->data, rd->data_size, 8);
131  printf ("\n");
132 }
133 
134 
143 static void
144 run_pkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label)
145 {
147  struct GNUNET_GNSRECORD_Block *rrblock;
148  char *bdata;
149  struct GNUNET_IDENTITY_PrivateKey id_priv;
150  struct GNUNET_IDENTITY_PublicKey id_pub;
151  struct GNUNET_IDENTITY_PrivateKey pkey_data_p;
152  struct GNUNET_IDENTITY_PublicKey pkey_data;
153  struct GNUNET_HashCode query;
154  char *rdata;
155  char *conv_lbl;
156  size_t rdata_size;
157  char ztld[128];
158  unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
159  unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH];
160 
161  id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
163  parsehex (d_pkey,
164  (char*) &id_priv.ecdsa_key,
165  sizeof (id_priv.ecdsa_key), 1);
166 
168  &id_pub);
169  printf ("Zone private key (d, big-endian):\n");
170  print_bytes_ (&id_priv.ecdsa_key,
171  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1);
172  printf ("\n");
173  printf ("Zone identifier (ztype|zkey):\n");
175  print_bytes (&id_pub, GNUNET_IDENTITY_public_key_get_length (&id_pub), 8);
178  &id_pub),
179  ztld,
180  sizeof (ztld));
181  printf ("\n");
182  printf ("zTLD:\n");
183  printf ("%s\n", ztld);
184  printf ("\n");
185 
186  pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
188  GNUNET_IDENTITY_key_get_public (&pkey_data_p,
189  &pkey_data);
190  conv_lbl = GNUNET_GNSRECORD_string_normalize (label);
191  printf ("Label:\n");
192  print_bytes (conv_lbl, strlen (conv_lbl), 8);
193  GNUNET_free (conv_lbl);
194  printf ("\nNumber of records (integer): %d\n\n", rd_count);
195 
196  for (int i = 0; i < rd_count; i++)
197  {
198  printf ("Record #%d := (\n", i);
199  print_record (&rd[i]);
200  printf (")\n\n");
201  }
202 
204  rd);
205  rdata = GNUNET_malloc (rdata_size);
207  rd,
208  (size_t) rdata_size,
209  rdata);
210  printf ("RDATA:\n");
211  print_bytes (rdata,
212  (size_t) rdata_size,
213  8);
214  printf ("\n");
218  skey,
219  label,
221  expire).abs_value_us__,
222  &id_pub.ecdsa_key);
223 
224  printf ("Encryption NONCE|EXPIRATION|BLOCK COUNTER:\n");
225  print_bytes (ctr, sizeof (ctr), 8);
226  printf ("\n");
227  printf ("Encryption key (K):\n");
228  print_bytes (skey, sizeof (skey), 8);
229  printf ("\n");
231  label,
232  &query);
233  printf ("Storage key (q):\n");
234  print_bytes (&query, sizeof (query), 8);
235  printf ("\n");
237  expire,
238  label,
239  rd,
240  rd_count,
241  &rrblock));
242  struct GNUNET_CRYPTO_EcdsaPublicKey derived_key;
243  struct GNUNET_CRYPTO_EcdsaPrivateKey *derived_privkey;
244 
246  label,
247  "gns",
248  &derived_key);
249  derived_privkey = GNUNET_CRYPTO_ecdsa_private_key_derive (&id_priv.ecdsa_key,
250  label,
251  "gns");
252  printf ("ZKDF(zkey):\n");
253  print_bytes (&derived_key, sizeof (derived_key), 8);
254  printf ("\n");
255  printf ("Derived private key (d', big-endian):\n");
256  print_bytes_ (derived_privkey, sizeof (*derived_privkey), 8, 1);
257  printf ("\n");
258  size_t bdata_size = ntohl (rrblock->size) - sizeof (struct
260 
261  GNUNET_free (derived_privkey);
262 
263  bdata = (char*) &(&rrblock->ecdsa_block)[1];
264  printf ("BDATA:\n");
265  print_bytes (bdata, bdata_size, 8);
266  printf ("\n");
267  printf ("RRBLOCK:\n");
268  print_bytes (rrblock, ntohl (rrblock->size), 8);
269  printf ("\n");
270  GNUNET_free (rdata);
271 }
272 
273 
282 static void
283 run_edkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char*label)
284 {
286  struct GNUNET_GNSRECORD_Block *rrblock;
287  char *bdata;
288  struct GNUNET_IDENTITY_PrivateKey id_priv;
289  struct GNUNET_IDENTITY_PublicKey id_pub;
290  struct GNUNET_IDENTITY_PrivateKey pkey_data_p;
291  struct GNUNET_IDENTITY_PublicKey pkey_data;
292  struct GNUNET_HashCode query;
293  char *rdata;
294  char *conv_lbl;
295  size_t rdata_size;
296 
297  char ztld[128];
298  unsigned char nonce[crypto_secretbox_NONCEBYTES];
299  unsigned char skey[crypto_secretbox_KEYBYTES];
300 
301  id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
304  &id_pub);
305 
306  id_priv.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA);
308  parsehex (d_edkey,
309  (char*) &id_priv.eddsa_key,
310  sizeof (id_priv.eddsa_key), 0);
312  &id_pub);
313  fprintf (stdout,
314  "Zone private key (d):\n");
315  print_bytes (&id_priv.eddsa_key, sizeof (struct
317  printf ("\n");
318  printf ("Zone identifier (ztype|zkey):\n");
320  print_bytes (&id_pub, GNUNET_IDENTITY_public_key_get_length (&id_pub), 8);
323  &id_pub),
324  ztld,
325  sizeof (ztld));
326  printf ("\n");
327  printf ("zTLD:\n");
328  printf ("%s\n", ztld);
329  printf ("\n");
330 
331  pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY);
333  GNUNET_IDENTITY_key_get_public (&pkey_data_p,
334  &pkey_data);
335  conv_lbl = GNUNET_GNSRECORD_string_normalize (label);
336  printf ("Label:\n");
337  print_bytes (conv_lbl, strlen (conv_lbl), 8);
338  GNUNET_free (conv_lbl);
339  fprintf (stdout,
340  "\nNumber of records (integer): %d\n\n", rd_count);
341 
342  for (int i = 0; i < rd_count; i++)
343  {
344  printf ("Record #%d := (\n", i);
345  print_record (&rd[i]);
346  printf (")\n\n");
347  }
348 
350  rd);
352  rd,
354  GNUNET_assert (0 < rdata_size);
355  rdata = GNUNET_malloc ((size_t) rdata_size);
357  rd,
358  (size_t) rdata_size,
359  rdata);
360  printf ("RDATA:\n");
361  print_bytes (rdata,
362  (size_t) rdata_size,
363  8);
364  printf ("\n");
366  skey,
367  label,
369  expire).abs_value_us__,
370  &id_pub.eddsa_key);
371  printf ("Encryption NONCE|EXPIRATION:\n");
372  print_bytes (nonce, sizeof (nonce), 8);
373  printf ("\n");
374  printf ("Encryption key (K):\n");
375  print_bytes (skey, sizeof (skey), 8);
376  printf ("\n");
378  label,
379  &query);
380  printf ("Storage key (q):\n");
381  print_bytes (&query, sizeof (query), 8);
382  printf ("\n");
383 
385  expire,
386  label,
387  rd,
388  rd_count,
389  &rrblock));
390 
391  struct GNUNET_CRYPTO_EddsaPublicKey derived_key;
392  struct GNUNET_CRYPTO_EddsaPrivateScalar derived_privkey;
394  label,
395  "gns",
396  &derived_key);
398  label,
399  "gns", &derived_privkey);
400  printf ("ZKDF(zkey):\n");
401  print_bytes (&derived_key, sizeof (derived_key), 8);
402  printf ("\n");
403  printf ("nonce := SHA-256 (dh[32..63] || h):\n");
404  print_bytes (derived_privkey.s + 32, 32, 8);
405  printf ("\n");
406  char derived_privkeyNBO[32];
407  /* Convert from little endian */
408  for (size_t i = 0; i < 32; i++)
409  derived_privkeyNBO[i] = derived_privkey.s[31 - i];
410  printf ("Derived private key (d', big-endian):\n");
411  print_bytes (derived_privkeyNBO, sizeof (derived_privkeyNBO), 8);
412  printf ("\n");
413  size_t bdata_size = ntohl (rrblock->size) - sizeof (struct
415 
416 
417  bdata = (char*) &(&rrblock->eddsa_block)[1];
418  printf ("BDATA:\n");
419  print_bytes (bdata, bdata_size, 8);
420  printf ("\n");
421  printf ("RRBLOCK:\n");
422  print_bytes (rrblock, ntohl (rrblock->size), 8);
423  printf ("\n");
424  GNUNET_free (rdata);
425 }
426 
427 
436 static void
437 run (void *cls,
438  char *const *args,
439  const char *cfgfile,
440  const struct GNUNET_CONFIGURATION_Handle *cfg)
441 {
442  struct GNUNET_GNSRECORD_Data rd_pkey;
443  struct GNUNET_GNSRECORD_Data rd[3];
444  struct GNUNET_TIME_Absolute exp1;
445  struct GNUNET_TIME_Absolute exp2;
446  struct GNUNET_TIME_Absolute exp3;
447  struct GNUNET_TIME_AbsoluteNBO exp1nbo;
448  struct GNUNET_TIME_AbsoluteNBO exp2nbo;
449  struct GNUNET_TIME_AbsoluteNBO exp3nbo;
450  size_t pkey_data_size;
451  size_t ip_data_size;
452  char *pkey_data;
453  char *ip_data;
454 
455  /*
456  * Make different expiration times
457  */
458  parsehex ("001cee8c10e25980", (char*) &exp1nbo, sizeof (exp1nbo), 0);
459  parsehex ("003ff2aa5408db40", (char*) &exp2nbo, sizeof (exp2nbo), 0);
460  parsehex ("0028bb13ff371940", (char*) &exp3nbo, sizeof (exp3nbo), 0);
461  exp1 = GNUNET_TIME_absolute_ntoh (exp1nbo);
462  exp2 = GNUNET_TIME_absolute_ntoh (exp2nbo);
463  exp3 = GNUNET_TIME_absolute_ntoh (exp3nbo);
464 
465  memset (&rd_pkey, 0, sizeof (struct GNUNET_GNSRECORD_Data));
468  "000G0011WESGZY9VRV9NNJ66W3GKNZFZF56BFD2BQF3MHMJST2G2GKDYGG",
469  (void**) &pkey_data,
470  &pkey_data_size));
471  rd_pkey.data = pkey_data;
472  rd_pkey.data_size = pkey_data_size;
473  rd_pkey.expiration_time = exp1.abs_value_us;
478  "::dead:beef",
479  (void**) &ip_data,
480  &ip_data_size));
481 
482  rd[0].data = ip_data;
483  rd[0].data_size = ip_data_size;
484  rd[0].expiration_time = exp1.abs_value_us;
487 
488  rd[1].data = "\u611b\u79f0";
489  rd[1].data_size = strlen (rd[1].data);
490  rd[1].expiration_time = exp2.abs_value_us;
493 
494  rd[2].data = "Hello World";
495  rd[2].data_size = strlen (rd[2].data);
496  rd[2].expiration_time = exp3.abs_value_us;
499 
500  run_pkey (&rd_pkey, 1, "testdelegation");
501  run_pkey (rd, 3, "\u5929\u4e0b\u7121\u6575");
502  run_edkey (&rd_pkey, 1, "testdelegation");
503  run_edkey (rd, 3, "\u5929\u4e0b\u7121\u6575");
504 }
505 
506 
514 int
515 main (int argc,
516  char *const *argv)
517 {
518  const struct GNUNET_GETOPT_CommandLineOption options[] = {
520  };
521 
523  GNUNET_log_setup ("gnunet-gns-tvg",
524  "INFO",
525  NULL));
526  // gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
527  // gcry_control (GCRYCTL_SET_VERBOSITY, 99);
528  if (GNUNET_OK !=
529  GNUNET_PROGRAM_run (argc, argv,
530  "gnunet-gns-tvg",
531  "Generate test vectors for GNS",
532  options,
533  &run, NULL))
534  return 1;
535  return 0;
536 }
537 
538 
539 /* end of gnunet-gns-tvg.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define GNUNET_GNSRECORD_TYPE_NICK
GNS zone nickname.
#define GNUNET_GNSRECORD_TYPE_PKEY
WARNING: This header is generated! In order to add GNS record types, you must register them in GANA,...
#define GNUNET_GNSRECORD_TYPE_EDKEY
GNS zone delegation (EDKEY)
void GNR_derive_block_xsalsa_key(unsigned char *nonce, unsigned char *key, const char *label, uint64_t exp, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Derive session key and iv from label and public key.
void GNR_derive_block_aes_key(unsigned char *ctr, unsigned char *key, const char *label, uint64_t exp, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Derive session key and iv from label and public key.
API for GNS record-related crypto.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * line
Desired phone line (string to be converted to a hash).
static char * expire
DID Document expiration Date Attribut String.
Definition: gnunet-did.c:101
static void print_bytes_(void *buf, size_t buf_len, int fold, int in_be)
static int parsehex(char *src, char *dst, size_t dstlen, int invert)
static void print_bytes(void *buf, size_t buf_len, int fold)
static char * d_edkey
static void print_record(const struct GNUNET_GNSRECORD_Data *rd)
static char * d_pkey
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
int main(int argc, char *const *argv)
The main function of the test vector generation tool.
static void run_pkey(struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label)
Main function that will be run.
static void run_edkey(struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label)
Main function that will be run.
uint32_t data
The data value.
static unsigned int rd_count
Number of records for currently parsed set.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static char buf[2048]
API to the GNS service.
API that can be used to manipulate GNS record data.
Convenience API for writing testcases for GNUnet.
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
void GNUNET_CRYPTO_eddsa_private_key_derive(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const char *label, const char *context, struct GNUNET_CRYPTO_EddsaPrivateScalar *result)
Derive a private scalar from a given private key and a label.
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:462
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:447
void GNUNET_CRYPTO_eddsa_public_key_derive(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EddsaPublicKey *result)
Derive a public key from a given public key and a label.
struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_private_key_derive(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const char *label, const char *context)
Derive a private key from a given private key and a label.
#define GNUNET_DNSPARSER_TYPE_AAAA
#define GNUNET_DNSPARSER_TYPE_TXT
char * GNUNET_GNSRECORD_string_normalize(const char *src)
Normalize a UTF-8 string to a GNS name.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_GNSRECORD_RF_CRITICAL
This record is critical.
@ GNUNET_GNSRECORD_RF_SUPPLEMENTAL
This is a supplemental record.
@ GNUNET_GNSRECORD_RF_NONE
Entry for no flags / cleared flags.
void GNUNET_GNSRECORD_query_from_public_key(const struct GNUNET_IDENTITY_PublicKey *pub, const char *label, struct GNUNET_HashCode *query)
Calculate the DHT query for a given label in a given zone.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create(const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **result)
Sign name and records.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
int GNUNET_GNSRECORD_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of the value s of a record of type type to the respective binary repre...
Definition: gnsrecord.c:177
struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_record_get_expiration_time(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute min)
Returns the expiration time of the given block of records.
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:179
ssize_t GNUNET_IDENTITY_public_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:830
@ GNUNET_IDENTITY_TYPE_EDDSA
EDDSA identity.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
#define GNUNET_CRYPTO_AES_KEY_LENGTH
length of the sessionkey in bytes (256 BIT sessionkey)
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
@ GNUNET_OK
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using CrockfordBase32.
Definition: strings.c:708
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Private ECC key encoded for transmission.
Private ECC scalar encoded for transmission.
unsigned char s[512/8]
s is the expandedprivate 512-bit scalar of a private key.
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
Definition of a command line option.
struct GNUNET_GNSRECORD_EcdsaBlock ecdsa_block
struct GNUNET_GNSRECORD_EddsaBlock eddsa_block
uint32_t size
Size of the block.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
A 512-bit hashcode.
A private key for an identity as per LSD0001.
uint32_t type
Type of public key.
struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_key
An ECDSA identity key.
struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_key
AN EdDSA identtiy key.
An identity key as per LSD0001.
struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_key
An ECDSA identity key.
struct GNUNET_CRYPTO_EddsaPublicKey eddsa_key
AN EdDSA identtiy key.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.