GNUnet 0.21.0
gnunet-gnsrecord-tvg.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_signatures.h"
#include "gnunet_gns_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_testing_lib.h"
#include "gnsrecord_crypto.h"
#include <inttypes.h>
Include dependency graph for gnunet-gnsrecord-tvg.c:

Go to the source code of this file.

Functions

static int parsehex (char *src, char *dst, size_t dstlen, int invert)
 
static void print_bytes_ (void *buf, size_t buf_len, int fold, int in_be)
 
static void print_bytes (void *buf, size_t buf_len, int fold)
 
static void print_record (const struct GNUNET_GNSRECORD_Data *rd)
 
static void run_pkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label)
 Main function that will be run. More...
 
static void run_edkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label)
 Main function that will be run. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Main function that will be run. More...
 
int main (int argc, char *const *argv)
 The main function of the test vector generation tool. More...
 

Variables

static char * d_pkey
 
static char * d_edkey
 

Function Documentation

◆ parsehex()

static int parsehex ( char *  src,
char *  dst,
size_t  dstlen,
int  invert 
)
static

Definition at line 44 of file gnunet-gnsrecord-tvg.c.

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}
static char * line
Desired phone line (string to be converted to a hash).
static char * data
The data to insert into the dht.

References data, and line.

Referenced by run(), run_edkey(), and run_pkey().

Here is the caller graph for this function:

◆ print_bytes_()

static void print_bytes_ ( void *  buf,
size_t  buf_len,
int  fold,
int  in_be 
)
static

Definition at line 65 of file gnunet-gnsrecord-tvg.c.

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}

Referenced by print_bytes(), and run_pkey().

Here is the caller graph for this function:

◆ print_bytes()

static void print_bytes ( void *  buf,
size_t  buf_len,
int  fold 
)
static

Definition at line 95 of file gnunet-gnsrecord-tvg.c.

98{
99 print_bytes_ (buf, buf_len, fold, 0);
100}
static void print_bytes_(void *buf, size_t buf_len, int fold, int in_be)

References print_bytes_().

Referenced by print_record(), run_edkey(), and run_pkey().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_record()

static void print_record ( const struct GNUNET_GNSRECORD_Data rd)
static

Definition at line 104 of file gnunet-gnsrecord-tvg.c.

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 {
115 rt.rel_value_us = rd->expiration_time;
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}
static void print_bytes(void *buf, size_t buf_len, int fold)
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
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
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.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_htonll(), GNUNET_ntohll(), GNUNET_TIME_relative_to_absolute(), print_bytes(), rd, GNUNET_GNSRECORD_Data::record_type, and GNUNET_TIME_Relative::rel_value_us.

Referenced by run_edkey(), and run_pkey().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run_pkey()

static void run_pkey ( struct GNUNET_GNSRECORD_Data rd,
int  rd_count,
const char *  label 
)
static

Main function that will be run.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 144 of file gnunet-gnsrecord-tvg.c.

145{
147 struct GNUNET_GNSRECORD_Block *rrblock;
148 char *bdata;
149 struct GNUNET_CRYPTO_PrivateKey id_priv;
150 struct GNUNET_CRYPTO_PublicKey id_pub;
151 struct GNUNET_CRYPTO_PrivateKey pkey_data_p;
152 struct GNUNET_CRYPTO_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);
162 GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key);
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_CRYPTO_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);
187 GNUNET_CRYPTO_ecdsa_key_create (&pkey_data_p.ecdsa_key);
188 GNUNET_CRYPTO_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
245 GNUNET_CRYPTO_ecdsa_public_key_derive (&id_pub.ecdsa_key,
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}
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.
static char * expire
DID Document expiration Date Attribut String.
Definition: gnunet-did.c:98
static int parsehex(char *src, char *dst, size_t dstlen, int invert)
static void print_record(const struct GNUNET_GNSRECORD_Data *rd)
static char * d_pkey
static unsigned int rd_count
Number of records for currently parsed set.
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.
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.
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:447
void GNUNET_GNSRECORD_query_from_public_key(const struct GNUNET_CRYPTO_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_CRYPTO_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **block)
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.
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.
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.
char * GNUNET_GNSRECORD_string_normalize(const char *src)
Normalize a UTF-8 string to a GNS name.
ssize_t GNUNET_CRYPTO_public_key_get_length(const struct GNUNET_CRYPTO_PublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_PublicKey.
Definition: crypto_pkey.c:68
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_key_get_public(const struct GNUNET_CRYPTO_PrivateKey *privkey, struct GNUNET_CRYPTO_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: crypto_pkey.c:602
#define GNUNET_CRYPTO_AES_KEY_LENGTH
length of the sessionkey in bytes (256 BIT sessionkey)
@ GNUNET_OK
#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.
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:709
#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
#define GNUNET_GNSRECORD_TYPE_PKEY
WARNING: This header is generated! In order to add GNS record types, you must register them in GANA,...
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
struct GNUNET_GNSRECORD_EcdsaBlock ecdsa_block
uint32_t size
Size of the block.
A 512-bit hashcode.

References d_pkey, GNUNET_GNSRECORD_Block::ecdsa_block, GNUNET_CRYPTO_PrivateKey::ecdsa_key, GNUNET_CRYPTO_PublicKey::ecdsa_key, expire, GNR_derive_block_aes_key(), GNUNET_assert, GNUNET_CRYPTO_AES_KEY_LENGTH, GNUNET_CRYPTO_ecdsa_key_create(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_key_get_public(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_free, GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_malloc, GNUNET_OK, GNUNET_STRINGS_data_to_string(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_ZERO_ABS, parsehex(), print_bytes(), print_bytes_(), print_record(), rd, rd_count, GNUNET_GNSRECORD_Block::size, and GNUNET_CRYPTO_PrivateKey::type.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run_edkey()

static void run_edkey ( struct GNUNET_GNSRECORD_Data rd,
int  rd_count,
const char *  label 
)
static

Main function that will be run.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 283 of file gnunet-gnsrecord-tvg.c.

284{
286 struct GNUNET_GNSRECORD_Block *rrblock;
287 char *bdata;
288 struct GNUNET_CRYPTO_PrivateKey id_priv;
289 struct GNUNET_CRYPTO_PublicKey id_pub;
290 struct GNUNET_CRYPTO_PrivateKey pkey_data_p;
291 struct GNUNET_CRYPTO_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);
302 GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key);
304 &id_pub);
305
306 id_priv.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
307 GNUNET_CRYPTO_eddsa_key_create (&id_priv.eddsa_key);
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_CRYPTO_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);
332 GNUNET_CRYPTO_eddsa_key_create (&pkey_data_p.eddsa_key);
333 GNUNET_CRYPTO_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;
393 GNUNET_CRYPTO_eddsa_public_key_derive (&id_pub.eddsa_key,
394 label,
395 "gns",
396 &derived_key);
397 GNUNET_CRYPTO_eddsa_private_key_derive (&id_priv.eddsa_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}
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.
static char * d_edkey
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_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.
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
#define GNUNET_GNSRECORD_TYPE_EDKEY
GNS zone delegation (EDKEY)
Private ECC key encoded for transmission.
Private ECC scalar encoded for transmission.
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
struct GNUNET_GNSRECORD_EddsaBlock eddsa_block

References d_edkey, GNUNET_CRYPTO_PrivateKey::ecdsa_key, GNUNET_GNSRECORD_Block::eddsa_block, GNUNET_CRYPTO_PrivateKey::eddsa_key, GNUNET_CRYPTO_PublicKey::eddsa_key, expire, GNR_derive_block_xsalsa_key(), GNUNET_assert, GNUNET_CRYPTO_ecdsa_key_create(), GNUNET_CRYPTO_eddsa_key_create(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_key_get_public(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_free, GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_malloc, GNUNET_OK, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_STRINGS_data_to_string(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_ZERO_ABS, parsehex(), print_bytes(), print_record(), rd, rd_count, GNUNET_CRYPTO_EddsaPrivateScalar::s, GNUNET_GNSRECORD_Block::size, and GNUNET_CRYPTO_PrivateKey::type.

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,
char *const *  args,
const char *  cfgfile,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Main function that will be run.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 437 of file gnunet-gnsrecord-tvg.c.

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;
474 rd_pkey.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
475 rd_pkey.flags = GNUNET_GNSRECORD_RF_CRITICAL;
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}
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.
#define GNUNET_DNSPARSER_TYPE_AAAA
#define GNUNET_DNSPARSER_TYPE_TXT
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
@ 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.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
#define GNUNET_GNSRECORD_TYPE_NICK
GNS zone nickname.
Time for absolute time used by GNUnet, in microseconds and in network byte order.

References GNUNET_TIME_Absolute::abs_value_us, data, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_TXT, GNUNET_GNSRECORD_RF_CRITICAL, GNUNET_GNSRECORD_RF_NONE, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_OK, GNUNET_TIME_absolute_ntoh(), parsehex(), rd, GNUNET_GNSRECORD_Data::record_type, run_edkey(), and run_pkey().

Referenced by main().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char *const *  argv 
)

The main function of the test vector generation tool.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 515 of file gnunet-gnsrecord-tvg.c.

517{
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}
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
enum GNUNET_GenericReturnValue GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
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
Definition of a command line option.

References GNUNET_assert, GNUNET_GETOPT_OPTION_END, GNUNET_log_setup(), GNUNET_OK, GNUNET_PROGRAM_run(), options, and run().

Here is the call graph for this function:

Variable Documentation

◆ d_pkey

char* d_pkey
static
Initial value:
=
"50d7b652a4efeadff37396909785e5952171a02178c8e7d450fa907925fafd98"

Definition at line 36 of file gnunet-gnsrecord-tvg.c.

Referenced by run_pkey().

◆ d_edkey

char* d_edkey
static
Initial value:
=
"5af7020ee19160328832352bbc6a68a8d71a7cbe1b929969a7c66d415a0d8f65"

Definition at line 39 of file gnunet-gnsrecord-tvg.c.

Referenced by run_edkey().