diff options
Diffstat (limited to 'src/gnsrecord/gnunet-gnsrecord-tvg.c')
-rw-r--r-- | src/gnsrecord/gnunet-gnsrecord-tvg.c | 475 |
1 files changed, 0 insertions, 475 deletions
diff --git a/src/gnsrecord/gnunet-gnsrecord-tvg.c b/src/gnsrecord/gnunet-gnsrecord-tvg.c deleted file mode 100644 index d45b3a5d8..000000000 --- a/src/gnsrecord/gnunet-gnsrecord-tvg.c +++ /dev/null | |||
@@ -1,475 +0,0 @@ | |||
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 | |||
21 | /** | ||
22 | * @file util/gnunet-gns-tvg.c | ||
23 | * @brief Generate test vectors for GNS. | ||
24 | * @author Martin Schanzenbach | ||
25 | */ | ||
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 | #include "gnsrecord_crypto.h" | ||
35 | |||
36 | |||
37 | static char *d_pkey = | ||
38 | "50d7b652a4efeadff37396909785e5952171a02178c8e7d450fa907925fafd98"; | ||
39 | |||
40 | static char *d_edkey = | ||
41 | "5af7020ee19160328832352bbc6a68a8d71a7cbe1b929969a7c66d415a0d8f65"; | ||
42 | |||
43 | |||
44 | static int | ||
45 | parsehex (char *src, char *dst, size_t dstlen, int invert) | ||
46 | { | ||
47 | char *line = src; | ||
48 | char *data = line; | ||
49 | int off; | ||
50 | int read_byte; | ||
51 | int data_len = 0; | ||
52 | |||
53 | while (sscanf (data, " %02x%n", &read_byte, &off) == 1) | ||
54 | { | ||
55 | if (invert) | ||
56 | dst[dstlen - 1 - data_len++] = read_byte; | ||
57 | else | ||
58 | dst[data_len++] = read_byte; | ||
59 | data += off; | ||
60 | } | ||
61 | return data_len; | ||
62 | } | ||
63 | |||
64 | |||
65 | static void | ||
66 | print_bytes_ (void *buf, | ||
67 | size_t buf_len, | ||
68 | int fold, | ||
69 | int in_be) | ||
70 | { | ||
71 | int i; | ||
72 | |||
73 | for (i = 0; i < buf_len; i++) | ||
74 | { | ||
75 | if ((0 != i) && (0 != fold) && (i % fold == 0)) | ||
76 | printf ("\n"); | ||
77 | if (in_be) | ||
78 | printf ("%02x", ((unsigned char*) buf)[buf_len - 1 - i]); | ||
79 | else | ||
80 | printf ("%02x", ((unsigned char*) buf)[i]); | ||
81 | } | ||
82 | printf ("\n"); | ||
83 | } | ||
84 | |||
85 | |||
86 | static void | ||
87 | print_bytes (void *buf, | ||
88 | size_t buf_len, | ||
89 | int fold) | ||
90 | { | ||
91 | print_bytes_ (buf, buf_len, fold, 0); | ||
92 | } | ||
93 | |||
94 | |||
95 | static void | ||
96 | print_record (const struct GNUNET_GNSRECORD_Data *rd) | ||
97 | { | ||
98 | uint16_t flags = htons (rd->flags); | ||
99 | uint64_t abs_nbo = GNUNET_htonll (rd->expiration_time); | ||
100 | uint16_t size_nbo = htons (rd->data_size); | ||
101 | uint32_t type_nbo = htonl (rd->record_type); | ||
102 | printf ("EXPIRATION:\n"); | ||
103 | print_bytes (&abs_nbo, sizeof (abs_nbo), 8); | ||
104 | printf ("\nDATA_SIZE:\n"); | ||
105 | print_bytes (&size_nbo, sizeof (size_nbo), 8); | ||
106 | printf ("\nTYPE:\n"); | ||
107 | print_bytes (&type_nbo, sizeof (type_nbo), 8); | ||
108 | printf ("\nFLAGS: "); | ||
109 | print_bytes ((void*) &flags, sizeof (flags), 8); | ||
110 | printf ("\n"); | ||
111 | fprintf (stdout, | ||
112 | "DATA:\n"); | ||
113 | print_bytes ((char*) rd->data, rd->data_size, 8); | ||
114 | printf ("\n"); | ||
115 | } | ||
116 | |||
117 | |||
118 | /** | ||
119 | * Main function that will be run. | ||
120 | * | ||
121 | * @param cls closure | ||
122 | * @param args remaining command-line arguments | ||
123 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | ||
124 | * @param cfg configuration | ||
125 | */ | ||
126 | static void | ||
127 | run_pkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label) | ||
128 | { | ||
129 | struct GNUNET_TIME_Absolute expire; | ||
130 | struct GNUNET_GNSRECORD_Block *rrblock; | ||
131 | char *bdata; | ||
132 | struct GNUNET_IDENTITY_PrivateKey id_priv; | ||
133 | struct GNUNET_IDENTITY_PublicKey id_pub; | ||
134 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; | ||
135 | struct GNUNET_IDENTITY_PublicKey pkey_data; | ||
136 | struct GNUNET_HashCode query; | ||
137 | char *rdata; | ||
138 | char *conv_lbl; | ||
139 | size_t rdata_size; | ||
140 | char ztld[128]; | ||
141 | unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2]; | ||
142 | unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH]; | ||
143 | |||
144 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); | ||
145 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); | ||
146 | parsehex (d_pkey, | ||
147 | (char*) &id_priv.ecdsa_key, | ||
148 | sizeof (id_priv.ecdsa_key), 1); | ||
149 | |||
150 | GNUNET_IDENTITY_key_get_public (&id_priv, | ||
151 | &id_pub); | ||
152 | printf ("Zone private key (d, big-endian):\n"); | ||
153 | print_bytes_ (&id_priv.ecdsa_key, | ||
154 | sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1); | ||
155 | printf ("\n"); | ||
156 | printf ("Zone identifier (ztype|zkey):\n"); | ||
157 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | ||
158 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | ||
159 | GNUNET_STRINGS_data_to_string (&id_pub, | ||
160 | GNUNET_IDENTITY_key_get_length (&id_pub), | ||
161 | ztld, | ||
162 | sizeof (ztld)); | ||
163 | printf ("\n"); | ||
164 | printf ("zTLD:\n"); | ||
165 | printf ("%s\n", ztld); | ||
166 | printf ("\n"); | ||
167 | |||
168 | pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); | ||
169 | GNUNET_CRYPTO_ecdsa_key_create (&pkey_data_p.ecdsa_key); | ||
170 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, | ||
171 | &pkey_data); | ||
172 | conv_lbl = GNUNET_GNSRECORD_string_normalize (label); | ||
173 | printf ("Label:\n"); | ||
174 | print_bytes (conv_lbl, strlen (conv_lbl), 8); | ||
175 | GNUNET_free (conv_lbl); | ||
176 | printf ("\Number of records (integer): %d\n\n", rd_count); | ||
177 | |||
178 | for (int i = 0; i < rd_count; i++) | ||
179 | { | ||
180 | printf ("Record #%d := (\n", i); | ||
181 | print_record (&rd[i]); | ||
182 | printf (")\n\n"); | ||
183 | } | ||
184 | |||
185 | rdata_size = GNUNET_GNSRECORD_records_get_size (rd_count, | ||
186 | rd); | ||
187 | rdata = GNUNET_malloc (rdata_size); | ||
188 | GNUNET_GNSRECORD_records_serialize (rd_count, | ||
189 | rd, | ||
190 | (size_t) rdata_size, | ||
191 | rdata); | ||
192 | printf ("RDATA:\n"); | ||
193 | print_bytes (rdata, | ||
194 | (size_t) rdata_size, | ||
195 | 8); | ||
196 | printf ("\n"); | ||
197 | expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_count, rd, | ||
198 | GNUNET_TIME_UNIT_ZERO_ABS); | ||
199 | GNR_derive_block_aes_key (ctr, | ||
200 | skey, | ||
201 | label, | ||
202 | GNUNET_TIME_absolute_hton ( | ||
203 | expire).abs_value_us__, | ||
204 | &id_pub.ecdsa_key); | ||
205 | |||
206 | printf ("Encryption NONCE|EXPIRATION|BLOCK COUNTER:\n"); | ||
207 | print_bytes (ctr, sizeof (ctr), 8); | ||
208 | printf ("\n"); | ||
209 | printf ("Encryption key (K):\n"); | ||
210 | print_bytes (skey, sizeof (skey), 8); | ||
211 | printf ("\n"); | ||
212 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, | ||
213 | label, | ||
214 | &query); | ||
215 | printf ("Storage key (q):\n"); | ||
216 | print_bytes (&query, sizeof (query), 8); | ||
217 | printf ("\n"); | ||
218 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, | ||
219 | expire, | ||
220 | label, | ||
221 | rd, | ||
222 | rd_count, | ||
223 | &rrblock)); | ||
224 | size_t bdata_size = ntohl (rrblock->size) - sizeof (struct | ||
225 | GNUNET_GNSRECORD_Block); | ||
226 | |||
227 | bdata = (char*) &(&rrblock->ecdsa_block)[1]; | ||
228 | printf ("BDATA:\n"); | ||
229 | print_bytes (bdata, bdata_size, 8); | ||
230 | printf ("\n"); | ||
231 | printf ("RRBLOCK:\n"); | ||
232 | print_bytes (rrblock, ntohl (rrblock->size), 8); | ||
233 | printf ("\n"); | ||
234 | GNUNET_free (rdata); | ||
235 | } | ||
236 | |||
237 | |||
238 | /** | ||
239 | * Main function that will be run. | ||
240 | * | ||
241 | * @param cls closure | ||
242 | * @param args remaining command-line arguments | ||
243 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | ||
244 | * @param cfg configuration | ||
245 | */ | ||
246 | static void | ||
247 | run_edkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char*label) | ||
248 | { | ||
249 | struct GNUNET_TIME_Absolute expire; | ||
250 | struct GNUNET_GNSRECORD_Block *rrblock; | ||
251 | char *bdata; | ||
252 | struct GNUNET_IDENTITY_PrivateKey id_priv; | ||
253 | struct GNUNET_IDENTITY_PublicKey id_pub; | ||
254 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; | ||
255 | struct GNUNET_IDENTITY_PublicKey pkey_data; | ||
256 | struct GNUNET_HashCode query; | ||
257 | char *rdata; | ||
258 | char *conv_lbl; | ||
259 | size_t rdata_size; | ||
260 | |||
261 | char ztld[128]; | ||
262 | unsigned char nonce[crypto_secretbox_NONCEBYTES]; | ||
263 | unsigned char skey[crypto_secretbox_KEYBYTES]; | ||
264 | |||
265 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); | ||
266 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); | ||
267 | GNUNET_IDENTITY_key_get_public (&id_priv, | ||
268 | &id_pub); | ||
269 | |||
270 | id_priv.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA); | ||
271 | GNUNET_CRYPTO_eddsa_key_create (&id_priv.eddsa_key); | ||
272 | parsehex (d_edkey, | ||
273 | (char*) &id_priv.eddsa_key, | ||
274 | sizeof (id_priv.eddsa_key), 0); | ||
275 | GNUNET_IDENTITY_key_get_public (&id_priv, | ||
276 | &id_pub); | ||
277 | fprintf (stdout, | ||
278 | "Zone private key (d):\n"); | ||
279 | print_bytes (&id_priv.eddsa_key, sizeof (struct | ||
280 | GNUNET_CRYPTO_EddsaPrivateKey), 8); | ||
281 | printf ("\n"); | ||
282 | printf ("Zone identifier (ztype|zkey):\n"); | ||
283 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | ||
284 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | ||
285 | GNUNET_STRINGS_data_to_string (&id_pub, | ||
286 | GNUNET_IDENTITY_key_get_length (&id_pub), | ||
287 | ztld, | ||
288 | sizeof (ztld)); | ||
289 | printf ("\n"); | ||
290 | printf ("zTLD:\n"); | ||
291 | printf ("%s\n", ztld); | ||
292 | printf ("\n"); | ||
293 | |||
294 | pkey_data_p.type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY); | ||
295 | GNUNET_CRYPTO_eddsa_key_create (&pkey_data_p.eddsa_key); | ||
296 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, | ||
297 | &pkey_data); | ||
298 | conv_lbl = GNUNET_GNSRECORD_string_normalize (label); | ||
299 | printf ("Label:\n"); | ||
300 | print_bytes (conv_lbl, strlen (conv_lbl), 8); | ||
301 | GNUNET_free (conv_lbl); | ||
302 | fprintf (stdout, | ||
303 | "\Number of records (integer): %d\n\n", rd_count); | ||
304 | |||
305 | for (int i = 0; i < rd_count; i++) | ||
306 | { | ||
307 | printf ("Record #%d := (\n", i); | ||
308 | print_record (&rd[i]); | ||
309 | printf (")\n\n"); | ||
310 | } | ||
311 | |||
312 | rdata_size = GNUNET_GNSRECORD_records_get_size (rd_count, | ||
313 | rd); | ||
314 | expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_count, | ||
315 | rd, | ||
316 | GNUNET_TIME_UNIT_ZERO_ABS); | ||
317 | GNUNET_assert (0 < rdata_size); | ||
318 | rdata = GNUNET_malloc ((size_t) rdata_size); | ||
319 | GNUNET_GNSRECORD_records_serialize (rd_count, | ||
320 | rd, | ||
321 | (size_t) rdata_size, | ||
322 | rdata); | ||
323 | printf ("RDATA:\n"); | ||
324 | print_bytes (rdata, | ||
325 | (size_t) rdata_size, | ||
326 | 8); | ||
327 | printf ("\n"); | ||
328 | GNR_derive_block_xsalsa_key (nonce, | ||
329 | skey, | ||
330 | label, | ||
331 | GNUNET_TIME_absolute_hton ( | ||
332 | expire).abs_value_us__, | ||
333 | &id_pub.eddsa_key); | ||
334 | printf ("Encryption NONCE|EXPIRATION:\n"); | ||
335 | print_bytes (nonce, sizeof (nonce), 8); | ||
336 | printf ("\n"); | ||
337 | printf ("Encryption key (K):\n"); | ||
338 | print_bytes (skey, sizeof (skey), 8); | ||
339 | printf ("\n"); | ||
340 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, | ||
341 | label, | ||
342 | &query); | ||
343 | printf ("Storage key (q):\n"); | ||
344 | print_bytes (&query, sizeof (query), 8); | ||
345 | printf ("\n"); | ||
346 | |||
347 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, | ||
348 | expire, | ||
349 | label, | ||
350 | rd, | ||
351 | rd_count, | ||
352 | &rrblock)); | ||
353 | size_t bdata_size = ntohl (rrblock->size) - sizeof (struct | ||
354 | GNUNET_GNSRECORD_Block); | ||
355 | |||
356 | bdata = (char*) &(&rrblock->eddsa_block)[1]; | ||
357 | printf ("BDATA:\n"); | ||
358 | print_bytes (bdata, bdata_size, 8); | ||
359 | printf ("\n"); | ||
360 | printf ("RRBLOCK:\n"); | ||
361 | print_bytes (rrblock, ntohl (rrblock->size), 8); | ||
362 | printf ("\n"); | ||
363 | GNUNET_free (rdata); | ||
364 | } | ||
365 | |||
366 | |||
367 | /** | ||
368 | * Main function that will be run. | ||
369 | * | ||
370 | * @param cls closure | ||
371 | * @param args remaining command-line arguments | ||
372 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | ||
373 | * @param cfg configuration | ||
374 | */ | ||
375 | static void | ||
376 | run (void *cls, | ||
377 | char *const *args, | ||
378 | const char *cfgfile, | ||
379 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
380 | { | ||
381 | struct GNUNET_GNSRECORD_Data rd_pkey; | ||
382 | struct GNUNET_GNSRECORD_Data rd[3]; | ||
383 | struct GNUNET_TIME_Absolute exp1; | ||
384 | struct GNUNET_TIME_Absolute exp2; | ||
385 | struct GNUNET_TIME_Relative exp3; | ||
386 | size_t pkey_data_size; | ||
387 | size_t ip_data_size; | ||
388 | char *pkey_data; | ||
389 | char *ip_data; | ||
390 | |||
391 | /* | ||
392 | * Make different expiration times | ||
393 | */ | ||
394 | GNUNET_STRINGS_fancy_time_to_absolute ("2048-01-23 10:51:34", | ||
395 | &exp1); | ||
396 | GNUNET_STRINGS_fancy_time_to_absolute ("3540-05-22 07:55:01", | ||
397 | &exp2); | ||
398 | GNUNET_STRINGS_fancy_time_to_relative ("100y", | ||
399 | &exp3); | ||
400 | |||
401 | |||
402 | memset (&rd_pkey, 0, sizeof (struct GNUNET_GNSRECORD_Data)); | ||
403 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
404 | GNUNET_GNSRECORD_TYPE_PKEY, | ||
405 | "000G0011WESGZY9VRV9NNJ66W3GKNZFZF56BFD2BQF3MHMJST2G2GKDYGG", | ||
406 | (void**) &pkey_data, | ||
407 | &pkey_data_size)); | ||
408 | rd_pkey.data = pkey_data; | ||
409 | rd_pkey.data_size = pkey_data_size; | ||
410 | rd_pkey.expiration_time = exp1.abs_value_us; | ||
411 | rd_pkey.record_type = GNUNET_GNSRECORD_TYPE_PKEY; | ||
412 | rd_pkey.flags = GNUNET_GNSRECORD_RF_CRITICAL; | ||
413 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
414 | GNUNET_DNSPARSER_TYPE_AAAA, | ||
415 | "::dead:beef", | ||
416 | (void**) &ip_data, | ||
417 | &ip_data_size)); | ||
418 | |||
419 | rd[0].data = ip_data; | ||
420 | rd[0].data_size = ip_data_size; | ||
421 | rd[0].expiration_time = exp1.abs_value_us; | ||
422 | rd[0].record_type = GNUNET_DNSPARSER_TYPE_AAAA; | ||
423 | rd[0].flags = GNUNET_GNSRECORD_RF_NONE; | ||
424 | |||
425 | rd[1].data = "\u611b\u79f0"; | ||
426 | rd[1].data_size = strlen (rd[1].data); | ||
427 | rd[1].expiration_time = exp2.abs_value_us; | ||
428 | rd[1].record_type = GNUNET_GNSRECORD_TYPE_NICK; | ||
429 | rd[1].flags = GNUNET_GNSRECORD_RF_PRIVATE; | ||
430 | |||
431 | rd[2].data = "Hello World"; | ||
432 | rd[2].data_size = strlen (rd[2].data); | ||
433 | rd[2].expiration_time = exp3.rel_value_us; | ||
434 | rd[2].record_type = GNUNET_DNSPARSER_TYPE_TXT; | ||
435 | rd[2].flags = GNUNET_GNSRECORD_RF_SUPPLEMENTAL | ||
436 | | GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; | ||
437 | |||
438 | run_pkey (&rd_pkey, 1, "testdelegation"); | ||
439 | run_pkey (rd, 3, "\u5929\u4e0b\u7121\u6575"); | ||
440 | run_edkey (&rd_pkey, 1, "testdelegation"); | ||
441 | run_edkey (rd, 3, "\u5929\u4e0b\u7121\u6575"); | ||
442 | } | ||
443 | |||
444 | |||
445 | /** | ||
446 | * The main function of the test vector generation tool. | ||
447 | * | ||
448 | * @param argc number of arguments from the command line | ||
449 | * @param argv command line arguments | ||
450 | * @return 0 ok, 1 on error | ||
451 | */ | ||
452 | int | ||
453 | main (int argc, | ||
454 | char *const *argv) | ||
455 | { | ||
456 | const struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
457 | GNUNET_GETOPT_OPTION_END | ||
458 | }; | ||
459 | |||
460 | GNUNET_assert (GNUNET_OK == | ||
461 | GNUNET_log_setup ("gnunet-gns-tvg", | ||
462 | "INFO", | ||
463 | NULL)); | ||
464 | if (GNUNET_OK != | ||
465 | GNUNET_PROGRAM_run (argc, argv, | ||
466 | "gnunet-gns-tvg", | ||
467 | "Generate test vectors for GNS", | ||
468 | options, | ||
469 | &run, NULL)) | ||
470 | return 1; | ||
471 | return 0; | ||
472 | } | ||
473 | |||
474 | |||
475 | /* end of gnunet-gns-tvg.c */ | ||