GNUnet  0.11.x
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_dnsparser_lib.h"
32 #include "gnunet_testing_lib.h"
33 #include <inttypes.h>
34 
35 #define TEST_RECORD_LABEL "test"
36 #define TEST_RECORD_A "1.2.3.4"
37 #define TEST_RRCOUNT 2
38 
39 static void
41  size_t buf_len,
42  int fold)
43 {
44  int i;
45 
46  for (i = 0; i < buf_len; i++)
47  {
48  if ((0 != i) && (0 != fold) && (i % fold == 0))
49  printf ("\n");
50  printf ("%02x", ((unsigned char*) buf)[i]);
51  }
52  printf ("\n");
53 }
54 
55 
56 static void
58 {
59 
60  fprintf (stdout,
61  "EXPIRATION: %" PRIu64 "\n", rd->expiration_time);
62  fprintf (stdout,
63  "DATA_SIZE: %zu\n", rd->data_size);
64  fprintf (stdout,
65  "TYPE: %d\n", rd->record_type);
66  fprintf (stdout,
67  "FLAGS: %d\n", rd->flags);
68  fprintf (stdout,
69  "DATA:\n");
70  print_bytes ((char*) rd->data, rd->data_size, 8);
71  fprintf (stdout, "\n");
72 }
73 
74 
83 static void
84 run_pkey (void)
85 {
86  struct GNUNET_GNSRECORD_Data rd[2];
88  struct GNUNET_GNSRECORD_Block *rrblock;
89  char *bdata;
90  struct GNUNET_IDENTITY_PrivateKey id_priv;
91  struct GNUNET_IDENTITY_PublicKey id_pub;
92  struct GNUNET_IDENTITY_PrivateKey pkey_data_p;
93  struct GNUNET_IDENTITY_PublicKey pkey_data;
94  void *data;
95  size_t data_size;
96  char *rdata;
97  size_t rdata_size;
98  char ztld[128];
99 
100  id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
103  &id_pub);
104  fprintf (stdout,
105  "Zone private key (d, little-endian, with ztype prepended):\n");
106  print_bytes (&id_priv, GNUNET_IDENTITY_key_get_length (&id_pub), 8); // FIXME length for privkey?
107  fprintf (stdout, "\n");
108  fprintf (stdout, "Zone identifier (zid):\n");
109  print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8);
112  ztld,
113  sizeof (ztld));
114  fprintf (stdout, "\n");
115  fprintf (stdout, "Encoded zone identifier (zkl = zTLD):\n");
116  fprintf (stdout, "%s\n", ztld);
117  fprintf (stdout, "\n");
118 
119  pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
121  GNUNET_IDENTITY_key_get_public (&pkey_data_p,
122  &pkey_data);
123  fprintf (stdout,
124  "Label: %s\nRRCOUNT: %d\n\n", TEST_RECORD_LABEL, TEST_RRCOUNT);
125  memset (rd, 0, sizeof (struct GNUNET_GNSRECORD_Data) * 2);
128  rd[0].data = data;
129  rd[0].data_size = data_size;
130  rd[0].expiration_time = exp_abs.abs_value_us;
132  fprintf (stdout, "Record #0\n");
133  print_record (&rd[0]);
134 
135  rd[1].data = &pkey_data;
136  rd[1].data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
137  rd[1].expiration_time = exp_abs.abs_value_us;
140  fprintf (stdout, "Record #1\n");
141  print_record (&rd[1]);
142 
143  rdata_size = GNUNET_GNSRECORD_records_get_size (2,
144  rd);
145  rdata = GNUNET_malloc (rdata_size);
147  rd,
148  rdata_size,
149  rdata);
150  fprintf (stdout, "RDATA:\n");
151  print_bytes (rdata, rdata_size, 8);
152  fprintf (stdout, "\n");
153  rrblock = GNUNET_GNSRECORD_block_create (&id_priv,
154  exp_abs,
156  rd,
157  TEST_RRCOUNT);
158  size_t bdata_size = ntohl (rrblock->ecdsa_block.purpose.size)
159  - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
160  - sizeof(struct GNUNET_TIME_AbsoluteNBO);
161  size_t ecblock_size = ntohl (rrblock->ecdsa_block.purpose.size)
162  + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
163  + sizeof(struct GNUNET_CRYPTO_EcdsaSignature);
164  size_t block_size = ecblock_size + sizeof (uint32_t);
165 
166  bdata = (char*) &(&rrblock->ecdsa_block)[1];
167  fprintf (stdout, "BDATA:\n");
168  print_bytes (bdata, bdata_size, 8);
169  fprintf (stdout, "\n");
170  fprintf (stdout, "RRBLOCK:\n");
171  print_bytes (rrblock, block_size, 8);
172  fprintf (stdout, "\n");
173  GNUNET_free (rdata);
174 }
175 
176 
185 static void
186 run_edkey (void)
187 {
188  struct GNUNET_GNSRECORD_Data rd[2];
190  struct GNUNET_GNSRECORD_Block *rrblock;
191  char *bdata;
192  struct GNUNET_IDENTITY_PrivateKey id_priv;
193  struct GNUNET_IDENTITY_PublicKey id_pub;
194  struct GNUNET_IDENTITY_PrivateKey pkey_data_p;
195  struct GNUNET_IDENTITY_PublicKey pkey_data;
196  void *data;
197  size_t data_size;
198  char *rdata;
199  size_t rdata_size;
200  char ztld[128];
201 
202  id_priv.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA);
205  &id_pub);
206  fprintf (stdout,
207  "Zone private key (d, little-endian, with ztype prepended):\n");
208  print_bytes (&id_priv, GNUNET_IDENTITY_key_get_length (&id_pub), 8); // FIXME length for privkey?
209  fprintf (stdout, "\n");
210  fprintf (stdout, "Zone identifier (zid):\n");
211  print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8);
214  ztld,
215  sizeof (ztld));
216  fprintf (stdout, "\n");
217  fprintf (stdout, "Encoded zone identifier (zkl = zTLD):\n");
218  fprintf (stdout, "%s\n", ztld);
219  fprintf (stdout, "\n");
220 
221  pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY);
223  GNUNET_IDENTITY_key_get_public (&pkey_data_p,
224  &pkey_data);
225  fprintf (stdout,
226  "Label: %s\nRRCOUNT: %d\n\n", TEST_RECORD_LABEL, TEST_RRCOUNT);
227  memset (rd, 0, sizeof (struct GNUNET_GNSRECORD_Data) * 2);
230  rd[0].data = data;
231  rd[0].data_size = data_size;
232  rd[0].expiration_time = exp_abs.abs_value_us;
234  fprintf (stdout, "Record #0\n");
235  print_record (&rd[0]);
236 
237  rd[1].data = &pkey_data;
238  rd[1].data_size = sizeof (struct GNUNET_CRYPTO_EddsaPublicKey);
239  rd[1].expiration_time = exp_abs.abs_value_us;
242  fprintf (stdout, "Record #1\n");
243  print_record (&rd[1]);
244 
245  rdata_size = GNUNET_GNSRECORD_records_get_size (2,
246  rd);
247  rdata = GNUNET_malloc (rdata_size);
249  rd,
250  rdata_size,
251  rdata);
252  fprintf (stdout, "RDATA:\n");
253  print_bytes (rdata, rdata_size, 8);
254  fprintf (stdout, "\n");
255  rrblock = GNUNET_GNSRECORD_block_create (&id_priv,
256  exp_abs,
258  rd,
259  TEST_RRCOUNT);
260  size_t bdata_size = ntohl (rrblock->eddsa_block.purpose.size)
261  - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
262  - sizeof(struct GNUNET_TIME_AbsoluteNBO);
263  size_t ecblock_size = ntohl (rrblock->eddsa_block.purpose.size)
264  + sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
265  + sizeof(struct GNUNET_CRYPTO_EddsaSignature);
266  size_t block_size = ecblock_size + sizeof (uint32_t);
267 
268  bdata = (char*) &(&rrblock->eddsa_block)[1];
269  fprintf (stdout, "BDATA:\n");
270  print_bytes (bdata, bdata_size, 8);
271  fprintf (stdout, "\n");
272  fprintf (stdout, "RRBLOCK:\n");
273  print_bytes (rrblock, block_size, 8);
274  fprintf (stdout, "\n");
275  GNUNET_free (rdata);
276 }
277 
278 
287 static void
288 run (void *cls,
289  char *const *args,
290  const char *cfgfile,
291  const struct GNUNET_CONFIGURATION_Handle *cfg)
292 {
293  run_pkey();
294  run_edkey();
295 }
296 
297 
305 int
306 main (int argc,
307  char *const *argv)
308 {
309  const struct GNUNET_GETOPT_CommandLineOption options[] = {
311  };
312 
314  GNUNET_log_setup ("gnunet-gns-tvg",
315  "INFO",
316  NULL));
317  if (GNUNET_OK !=
318  GNUNET_PROGRAM_run (argc, argv,
319  "gnunet-gns-tvg",
320  "Generate test vectors for GNS",
321  options,
322  &run, NULL))
323  return 1;
324  return 0;
325 }
326 
327 
328 /* 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_PKEY
WARNING: This header is generated! In order to add GNS record types, you must register them in GANA,...
#define GNUNET_GNSRECORD_TYPE_EDKEY
Record type for EDKEY zone delegations.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define TEST_RECORD_A
#define TEST_RECORD_LABEL
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(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
#define TEST_RRCOUNT
static void run_pkey(void)
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_edkey(void)
Main function that will be run.
uint32_t data
The data value.
static char buf[2048]
@ GNUNET_OK
Definition: gnunet_common.h:95
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:461
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:446
#define GNUNET_DNSPARSER_TYPE_A
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 a 'value' of a record to the binary representation.
Definition: gnsrecord.c:188
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.
struct GNUNET_GNSRECORD_Block * 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)
Sign name and records.
@ GNUNET_GNSRECORD_RF_PRIVATE
This is a private record of this peer and it should thus not be handed out to other peers.
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:175
ssize_t GNUNET_IDENTITY_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:976
@ GNUNET_IDENTITY_TYPE_EDDSA
EDDSA identity.
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:364
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:695
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
an ECC signature using ECDSA
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
an ECC signature using EdDSA.
Definition of a command line option.
struct GNUNET_GNSRECORD_EcdsaBlock ecdsa_block
struct GNUNET_GNSRECORD_EddsaBlock eddsa_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.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Number of bytes signed; also specifies the number of bytes of encrypted data that follow.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Number of bytes signed; also specifies the number of bytes of encrypted data that follow.
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.
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.