GNUnet 0.28.0
 
Loading...
Searching...
No Matches
gnsrecord_crypto.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009-2013, 2018 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
28#include "platform.h"
29#include "gnsrecord_crypto.h"
30
31#define LOG(kind, ...) GNUNET_log_from (kind, "gnsrecord", __VA_ARGS__)
32
38#pragma GCC diagnostic push
39#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
40void
41GNR_derive_block_aes_key (unsigned char *ctr,
42 unsigned char *key,
43 const char *label,
44 uint64_t exp,
45 const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
46{
47 static const char ctx_key[] = "gns-aes-ctx-key";
48 static const char ctx_iv[] = "gns-aes-ctx-iv";
49
50 GNUNET_CRYPTO_hkdf_gnunet (key, GNUNET_CRYPTO_AES_KEY_LENGTH,
51 ctx_key, strlen (ctx_key),
52 pub, sizeof(struct
53 GNUNET_CRYPTO_EcdsaPublicKey),
54 GNUNET_CRYPTO_kdf_arg_string (label));
55 memset (ctr, 0, GNUNET_CRYPTO_AES_KEY_LENGTH / 2);
57 GNUNET_CRYPTO_hkdf_gnunet (ctr, 4,
58 ctx_iv, strlen (ctx_iv),
59 pub, sizeof(struct
60 GNUNET_CRYPTO_EcdsaPublicKey),
61 GNUNET_CRYPTO_kdf_arg_string (label));
63 memcpy (ctr + 4, &exp, sizeof (exp));
65 ctr[15] |= 0x01;
66}
67
68
69void
70GNR_derive_block_xsalsa_key (struct GNUNET_CRYPTO_XSalsa20Nonce *nonce,
71 struct GNUNET_CRYPTO_XSalsa20SecretKey *key,
72 const char *label,
73 uint64_t exp,
74 const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
75{
76 static const char ctx_key[] = "gns-xsalsa-ctx-key";
77 static const char ctx_iv[] = "gns-xsalsa-ctx-iv";
78
79 GNUNET_CRYPTO_hkdf_gnunet (
80 key, crypto_secretbox_KEYBYTES,
81 ctx_key, strlen (ctx_key),
82 pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
83 GNUNET_CRYPTO_kdf_arg_string (label));
84 memset (nonce, 0, crypto_secretbox_NONCEBYTES);
86 GNUNET_CRYPTO_hkdf_gnunet (
87 nonce, (crypto_secretbox_NONCEBYTES - sizeof (exp)),
88 ctx_iv, strlen (ctx_iv),
89 pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
90 GNUNET_CRYPTO_kdf_arg_string (label));
92 memcpy (&nonce->nonce[crypto_secretbox_NONCEBYTES - sizeof (exp)],
93 &exp,
94 sizeof (exp));
95}
96
97
98static enum GNUNET_GenericReturnValue
99block_sign_ecdsa (const struct
100 GNUNET_CRYPTO_EcdsaPrivateKey *key,
101 const struct
102 GNUNET_CRYPTO_EcdsaPublicKey *pkey,
103 const char *label,
104 struct GNUNET_GNSRECORD_Block *block)
105{
106 struct GNRBlockPS *gnr_block;
107 struct GNUNET_GNSRECORD_EcdsaBlock *ecblock;
108 size_t size = ntohl (block->size) - sizeof (*block) + sizeof (*gnr_block);
109
110 gnr_block = GNUNET_malloc (size);
111 ecblock = &(block)->ecdsa_block;
112 gnr_block->purpose.size = htonl (size);
113 gnr_block->purpose.purpose =
114 htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
115 gnr_block->expiration_time = ecblock->expiration_time;
116 /* encrypt and sign */
117 GNUNET_memcpy (&gnr_block[1], &ecblock[1],
118 size - sizeof (*gnr_block));
119 GNUNET_CRYPTO_ecdsa_public_key_derive (pkey,
120 label,
121 "gns",
122 &ecblock->derived_key);
123 if (GNUNET_OK !=
124 GNUNET_CRYPTO_ecdsa_sign_derived (key,
125 label,
126 "gns",
127 &gnr_block->purpose,
128 &ecblock->signature))
129 {
130 GNUNET_break (0);
131 GNUNET_free (gnr_block);
132 return GNUNET_SYSERR;
133 }
134 GNUNET_free (gnr_block);
135 return GNUNET_OK;
136}
137
138
139static enum GNUNET_GenericReturnValue
140block_sign_eddsa (const struct
141 GNUNET_CRYPTO_EddsaPrivateKey *key,
142 const struct
143 GNUNET_CRYPTO_EddsaPublicKey *pkey,
144 const char *label,
145 struct GNUNET_GNSRECORD_Block *block)
146{
147 struct GNRBlockPS *gnr_block;
148 struct GNUNET_GNSRECORD_EddsaBlock *edblock;
149 size_t size = ntohl (block->size) - sizeof (*block) + sizeof (*gnr_block);
150 gnr_block = GNUNET_malloc (size);
151 edblock = &(block)->eddsa_block;
152 gnr_block->purpose.size = htonl (size);
153 gnr_block->purpose.purpose =
154 htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
155 gnr_block->expiration_time = edblock->expiration_time;
156 GNUNET_memcpy (&gnr_block[1], &edblock[1],
157 size - sizeof (*gnr_block));
158 /* encrypt and sign */
159 GNUNET_CRYPTO_eddsa_public_key_derive (pkey,
160 label,
161 "gns",
162 &edblock->derived_key);
163 GNUNET_CRYPTO_eddsa_sign_derived (key,
164 label,
165 "gns",
166 &gnr_block->purpose,
167 &edblock->signature);
168 GNUNET_free (gnr_block);
169 return GNUNET_OK;
170}
171
172
173enum GNUNET_GenericReturnValue
174GNUNET_GNSRECORD_block_sign (const struct
175 GNUNET_CRYPTO_BlindablePrivateKey *key,
176 const char *label,
177 struct GNUNET_GNSRECORD_Block *block)
178{
179 struct GNUNET_CRYPTO_BlindablePublicKey pkey;
180 enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
181 char *norm_label;
182
183 GNUNET_CRYPTO_blindable_key_get_public (key,
184 &pkey);
185 norm_label = GNUNET_GNSRECORD_string_normalize (label);
186
187 switch (ntohl (key->type))
188 {
189 case GNUNET_GNSRECORD_TYPE_PKEY:
190 res = block_sign_ecdsa (&key->ecdsa_key,
191 &pkey.ecdsa_key,
192 norm_label,
193 block);
194 break;
195 case GNUNET_GNSRECORD_TYPE_EDKEY:
196 res = block_sign_eddsa (&key->eddsa_key,
197 &pkey.eddsa_key,
198 norm_label,
199 block);
200 break;
201 default:
202 GNUNET_assert (0);
203 }
204 GNUNET_free (norm_label);
205 return res;
206}
207
208
222static enum GNUNET_GenericReturnValue
223block_create_ecdsa (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
224 const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey,
225 struct GNUNET_TIME_Absolute expire,
226 const char *label,
227 const unsigned char *rdata,
228 size_t rdata_len,
229 struct GNUNET_GNSRECORD_Block **block,
230 int sign)
231{
232 struct GNUNET_GNSRECORD_EcdsaBlock *ecblock;
233 unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
234 unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH];
235
236 if (rdata_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
237 {
238 GNUNET_break (0);
239 return GNUNET_SYSERR;
240 }
241 /* serialize */
242 *block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) + rdata_len);
243 (*block)->size = htonl (sizeof (struct GNUNET_GNSRECORD_Block) + rdata_len);
244 {
245 ecblock = &(*block)->ecdsa_block;
246 (*block)->type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
247 ecblock->expiration_time = GNUNET_TIME_absolute_hton (expire);
248 GNR_derive_block_aes_key (ctr,
249 skey,
250 label,
251 ecblock->expiration_time.abs_value_us__,
252 pkey);
253 GNUNET_CRYPTO_aes_ctr (rdata,
254 rdata_len,
255 skey,
256 ctr,
257 &ecblock[1]);
258 }
259 if (GNUNET_YES != sign)
260 return GNUNET_OK;
261 if (GNUNET_OK !=
262 block_sign_ecdsa (key, pkey, label, *block))
263 {
264 GNUNET_break (0);
265 GNUNET_free (*block);
266 return GNUNET_SYSERR;
267 }
268 return GNUNET_OK;
269}
270
271
285static enum GNUNET_GenericReturnValue
286block_create_eddsa (const struct GNUNET_CRYPTO_EddsaPrivateKey *key,
287 const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
288 struct GNUNET_TIME_Absolute expire,
289 const char *label,
290 const unsigned char *rdata,
291 size_t rdata_len,
292 struct GNUNET_GNSRECORD_Block **block,
293 int sign)
294{
295 struct GNUNET_GNSRECORD_EddsaBlock *edblock;
296 struct GNUNET_CRYPTO_XSalsa20SecretKey skey;
297 struct GNUNET_CRYPTO_XSalsa20Nonce nonce;
298
299 if (rdata_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
300 {
301 GNUNET_break (0);
302 return GNUNET_SYSERR;
303 }
304 /* serialize */
305 *block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block)
306 + rdata_len + crypto_secretbox_MACBYTES);
307 (*block)->size = htonl (sizeof (struct GNUNET_GNSRECORD_Block)
308 + rdata_len + crypto_secretbox_MACBYTES);
309 {
310 edblock = &(*block)->eddsa_block;
311 (*block)->type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY);
312 edblock->expiration_time = GNUNET_TIME_absolute_hton (expire);
313 GNR_derive_block_xsalsa_key (&nonce,
314 &skey,
315 label,
316 edblock->expiration_time.abs_value_us__,
317 pkey);
318 GNUNET_assert (GNUNET_OK ==
319 GNUNET_CRYPTO_xsalsa20poly1305_encrypt (
320 rdata_len,
321 (unsigned char*) rdata,
322 &skey,
323 &nonce,
324 &edblock[1]));
325 if (GNUNET_YES != sign)
326 return GNUNET_OK;
327 block_sign_eddsa (key, pkey, label, *block);
328 }
329 return GNUNET_OK;
330}
331
332
348
349static enum GNUNET_GenericReturnValue
350block_create2 (const struct GNUNET_CRYPTO_BlindablePrivateKey *pkey,
351 struct GNUNET_TIME_Absolute expire,
352 const char *label,
353 const unsigned char *rdata,
354 size_t rdata_len,
355 struct GNUNET_GNSRECORD_Block **result,
356 int sign)
357{
358 const struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
359 struct GNUNET_CRYPTO_EddsaPublicKey edpubkey;
360 enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
361 char *norm_label;
362#define CSIZE 64
363 static struct KeyCacheLine cache[CSIZE];
364 struct KeyCacheLine *line;
365
366 norm_label = GNUNET_GNSRECORD_string_normalize (label);
367
368 if (GNUNET_PUBLIC_KEY_TYPE_ECDSA == ntohl (pkey->type))
369 {
370 key = &pkey->ecdsa_key;
371
372 line = &cache[(*(unsigned int *) key) % CSIZE];
373 if (0 != memcmp (&line->key,
374 key,
375 sizeof(*key)))
376 {
377 /* cache miss, recompute */
378 line->key = *key;
379 GNUNET_CRYPTO_ecdsa_key_get_public (key,
380 &line->pkey);
381 }
382 res = block_create_ecdsa (key,
383 &line->pkey,
384 expire,
385 norm_label,
386 rdata,
387 rdata_len,
388 result,
389 sign);
390 }
391 else if (GNUNET_PUBLIC_KEY_TYPE_EDDSA == ntohl (pkey->type))
392 {
393 GNUNET_CRYPTO_eddsa_key_get_public (&pkey->eddsa_key,
394 &edpubkey);
395 res = block_create_eddsa (&pkey->eddsa_key,
396 &edpubkey,
397 expire,
398 norm_label,
399 rdata,
400 rdata_len,
401 result,
402 sign);
403 }
404#undef CSIZE
405 GNUNET_free (norm_label);
406 return res;
407}
408
409
417enum GNUNET_GenericReturnValue
418GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
419{
420 struct GNRBlockPS *purp;
421 size_t payload_len = ntohl (block->size)
422 - sizeof (struct GNUNET_GNSRECORD_Block);
423 enum GNUNET_GenericReturnValue res = GNUNET_NO;
424
425 if (ntohl (block->size) <
426 sizeof (struct GNUNET_GNSRECORD_Block))
427 {
428 GNUNET_break_op (0);
429 return GNUNET_SYSERR;
430 }
431 GNUNET_assert (payload_len <= UINT16_MAX);
432 purp = GNUNET_malloc (sizeof (struct GNRBlockPS) + payload_len);
433 purp->purpose.size = htonl (sizeof (struct GNRBlockPS) + payload_len);
434 purp->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
435 GNUNET_memcpy (&purp[1],
436 &block[1],
437 payload_len);
438 switch (ntohl (block->type))
439 {
440 case GNUNET_GNSRECORD_TYPE_PKEY:
441 purp->expiration_time = block->ecdsa_block.expiration_time;
442 res = GNUNET_CRYPTO_ecdsa_verify_ (
443 GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
444 &purp->purpose,
445 &block->ecdsa_block.signature,
446 &block->ecdsa_block.derived_key);
447 break;
448 case GNUNET_GNSRECORD_TYPE_EDKEY:
449 purp->expiration_time = block->eddsa_block.expiration_time;
450 res = GNUNET_CRYPTO_eddsa_verify_ (
451 GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
452 &purp->purpose,
453 &block->eddsa_block.signature,
454 &block->eddsa_block.derived_key);
455 break;
456 default:
457 res = GNUNET_NO;
458 }
459 GNUNET_free (purp);
460 return res;
461}
462
463
464static enum GNUNET_GenericReturnValue
465block_decrypt_ecdsa (
466 const struct GNUNET_GNSRECORD_Block *block,
467 const struct GNUNET_CRYPTO_EcdsaPublicKey *zone_key,
468 const char *label,
469 GNUNET_GNSRECORD_RecordCallback proc,
470 void *proc_cls)
471{
472 size_t payload_len = ntohl (block->size)
473 - sizeof (struct GNUNET_GNSRECORD_Block);
474 unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
475 unsigned char key[GNUNET_CRYPTO_AES_KEY_LENGTH];
476
477 if (ntohl (block->size) <
478 sizeof (struct GNUNET_GNSRECORD_Block))
479 {
480 GNUNET_break_op (0);
481 return GNUNET_SYSERR;
482 }
483 if (payload_len > UINT16_MAX)
484 {
485 GNUNET_break_op (0);
486 return GNUNET_SYSERR;
487 }
488 GNR_derive_block_aes_key (ctr,
489 key,
490 label,
491 block->ecdsa_block.expiration_time.abs_value_us__,
492 zone_key);
493 {
494 char payload[payload_len];
495 unsigned int rd_count;
496
497 GNUNET_CRYPTO_aes_ctr (&block[1],
498 payload_len,
499 key,
500 ctr,
501 payload);
502 rd_count = GNUNET_GNSRECORD_records_deserialize_get_size (payload_len,
503 payload);
504 if (rd_count > 2048)
505 {
506 /* limit to sane value */
507 GNUNET_break_op (0);
508 return GNUNET_SYSERR;
509 }
510 {
511 struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
512 unsigned int j;
513 struct GNUNET_TIME_Absolute now;
514
515 if (GNUNET_OK !=
516 GNUNET_GNSRECORD_records_deserialize (payload_len,
517 payload,
518 rd_count,
519 rd))
520 {
521 GNUNET_break_op (0);
522 return GNUNET_SYSERR;
523 }
524 /* hide expired records */
525 now = GNUNET_TIME_absolute_get ();
526 j = 0;
527 for (unsigned int i = 0; i < rd_count; i++)
528 {
529 if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
530 {
531 /* encrypted blocks must never have relative expiration times, skip! */
532 GNUNET_break_op (0);
533 continue;
534 }
535
536 if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW))
537 {
538 int include_record = GNUNET_YES;
539 /* Shadow record, figure out if we have a not expired active record */
540 for (unsigned int k = 0; k < rd_count; k++)
541 {
542 if (k == i)
543 continue;
544 if (rd[i].expiration_time < now.abs_value_us)
545 include_record = GNUNET_NO; /* Shadow record is expired */
546 if ((rd[k].record_type == rd[i].record_type) &&
547 (rd[k].expiration_time >= now.abs_value_us) &&
548 (0 == (rd[k].flags & GNUNET_GNSRECORD_RF_SHADOW)))
549 {
550 include_record = GNUNET_NO; /* We have a non-expired, non-shadow record of the same type */
551 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
552 "Ignoring shadow record\n");
553 break;
554 }
555 }
556 if (GNUNET_YES == include_record)
557 {
558 rd[i].flags ^= GNUNET_GNSRECORD_RF_SHADOW; /* Remove Flag */
559 if (j != i)
560 rd[j] = rd[i];
561 j++;
562 }
563 }
564 else if (rd[i].expiration_time >= now.abs_value_us)
565 {
566 /* Include this record */
567 if (j != i)
568 rd[j] = rd[i];
569 j++;
570 }
571 else
572 {
573 struct GNUNET_TIME_Absolute at;
574
575 at.abs_value_us = rd[i].expiration_time;
576 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
577 "Excluding record that expired %s (%llu ago)\n",
578 GNUNET_STRINGS_absolute_time_to_string (at),
579 (unsigned long long) rd[i].expiration_time
580 - now.abs_value_us);
581 }
582 }
583 rd_count = j;
584 if (NULL != proc)
585 proc (proc_cls,
586 rd_count,
587 (0 != rd_count) ? rd : NULL);
588 }
589 }
590 return GNUNET_OK;
591}
592
593
594static enum GNUNET_GenericReturnValue
595block_decrypt_eddsa (const struct GNUNET_GNSRECORD_Block *block,
596 const struct
597 GNUNET_CRYPTO_EddsaPublicKey *zone_key,
598 const char *label,
599 GNUNET_GNSRECORD_RecordCallback proc,
600 void *proc_cls)
601{
602 size_t payload_len = ntohl (block->size)
603 - sizeof (struct GNUNET_GNSRECORD_Block);
604 struct GNUNET_CRYPTO_XSalsa20SecretKey skey;
605 struct GNUNET_CRYPTO_XSalsa20Nonce nonce;
606
607
608 if (ntohl (block->size) <
609 sizeof(struct GNUNET_GNSRECORD_Block))
610 {
611 GNUNET_break_op (0);
612 return GNUNET_SYSERR;
613 }
614 if (payload_len > UINT16_MAX)
615 {
616 GNUNET_break_op (0);
617 return GNUNET_SYSERR;
618 }
619 GNR_derive_block_xsalsa_key (&nonce,
620 &skey,
621 label,
622 block->eddsa_block.expiration_time.abs_value_us__
623 ,
624 zone_key);
625 {
626 char payload[payload_len];
627 unsigned int rd_count;
628
629 if (GNUNET_OK !=
630 GNUNET_CRYPTO_xsalsa20poly1305_decrypt (
631 payload_len,
632 (unsigned char*) &block[1],
633 &skey,
634 &nonce,
635 payload))
636 {
637 GNUNET_break_op (0);
638 return GNUNET_SYSERR;
639 }
640 payload_len -= crypto_secretbox_MACBYTES;
641 rd_count = GNUNET_GNSRECORD_records_deserialize_get_size (payload_len,
642 payload);
643 if (rd_count > 2048)
644 {
645 /* limit to sane value */
646 GNUNET_break_op (0);
647 return GNUNET_SYSERR;
648 }
649 {
650 struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
651 unsigned int j;
652 struct GNUNET_TIME_Absolute now;
653
654 if (GNUNET_OK !=
655 GNUNET_GNSRECORD_records_deserialize (payload_len,
656 payload,
657 rd_count,
658 rd))
659 {
660 GNUNET_break_op (0);
661 return GNUNET_SYSERR;
662 }
663 /* hide expired records */
664 now = GNUNET_TIME_absolute_get ();
665 j = 0;
666 for (unsigned int i = 0; i < rd_count; i++)
667 {
668 if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
669 {
670 /* encrypted blocks must never have relative expiration times, skip! */
671 GNUNET_break_op (0);
672 continue;
673 }
674
675 if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW))
676 {
677 int include_record = GNUNET_YES;
678 /* Shadow record, figure out if we have a not expired active record */
679 for (unsigned int k = 0; k < rd_count; k++)
680 {
681 if (k == i)
682 continue;
683 if (rd[i].expiration_time < now.abs_value_us)
684 include_record = GNUNET_NO; /* Shadow record is expired */
685 if ((rd[k].record_type == rd[i].record_type) &&
686 (rd[k].expiration_time >= now.abs_value_us) &&
687 (0 == (rd[k].flags & GNUNET_GNSRECORD_RF_SHADOW)))
688 {
689 include_record = GNUNET_NO; /* We have a non-expired, non-shadow record of the same type */
690 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
691 "Ignoring shadow record\n");
692 break;
693 }
694 }
695 if (GNUNET_YES == include_record)
696 {
697 rd[i].flags ^= GNUNET_GNSRECORD_RF_SHADOW; /* Remove Flag */
698 if (j != i)
699 rd[j] = rd[i];
700 j++;
701 }
702 }
703 else if (rd[i].expiration_time >= now.abs_value_us)
704 {
705 /* Include this record */
706 if (j != i)
707 rd[j] = rd[i];
708 j++;
709 }
710 else
711 {
712 struct GNUNET_TIME_Absolute at;
713
714 at.abs_value_us = rd[i].expiration_time;
715 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
716 "Excluding record that expired %s (%llu ago)\n",
717 GNUNET_STRINGS_absolute_time_to_string (at),
718 (unsigned long long) rd[i].expiration_time
719 - now.abs_value_us);
720 }
721 }
722 rd_count = j;
723 if (NULL != proc)
724 proc (proc_cls,
725 rd_count,
726 (0 != rd_count) ? rd : NULL);
727 }
728 }
729 return GNUNET_OK;
730}
731
732
733#pragma GCC diagnostic pop
734
742void
743GNUNET_GNSRECORD_query_from_private_key (const struct
744 GNUNET_CRYPTO_BlindablePrivateKey *zone
745 ,
746 const char *label,
747 struct GNUNET_HashCode *query)
748{
749 char *norm_label;
750 struct GNUNET_CRYPTO_BlindablePublicKey pub;
751
752 norm_label = GNUNET_GNSRECORD_string_normalize (label);
753 switch (ntohl (zone->type))
754 {
755 case GNUNET_GNSRECORD_TYPE_PKEY:
756 case GNUNET_GNSRECORD_TYPE_EDKEY:
757
758 GNUNET_CRYPTO_blindable_key_get_public (zone,
759 &pub);
760 GNUNET_GNSRECORD_query_from_public_key (&pub,
761 norm_label,
762 query);
763 break;
764 default:
765 GNUNET_assert (0);
766 }
767 GNUNET_free (norm_label);
768}
769
770
771#pragma GCC diagnostic push
772#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
773void
774GNUNET_GNSRECORD_query_from_public_key (const struct
775 GNUNET_CRYPTO_BlindablePublicKey *pub,
776 const char *label,
777 struct GNUNET_HashCode *query)
778{
779 char *norm_label;
780 struct GNUNET_CRYPTO_BlindablePublicKey pd;
781
782 norm_label = GNUNET_GNSRECORD_string_normalize (label);
783
784 switch (ntohl (pub->type))
785 {
786 case GNUNET_GNSRECORD_TYPE_PKEY:
787 pd.type = pub->type;
788 GNUNET_CRYPTO_ecdsa_public_key_derive (&pub->ecdsa_key,
789 norm_label,
790 "gns",
791 &pd.ecdsa_key);
792 GNUNET_CRYPTO_hash (&pd.ecdsa_key,
793 sizeof (pd.ecdsa_key),
794 query);
795 break;
796 case GNUNET_GNSRECORD_TYPE_EDKEY:
797 pd.type = pub->type;
798 GNUNET_CRYPTO_eddsa_public_key_derive (&pub->eddsa_key,
799 norm_label,
800 "gns",
801 &(pd.eddsa_key));
802 GNUNET_CRYPTO_hash (&pd.eddsa_key,
803 sizeof (pd.eddsa_key),
804 query);
805 break;
806 default:
807 GNUNET_assert (0);
808 }
809 GNUNET_free (norm_label);
810}
811
812
813#pragma GCC diagnostic pop
814
821
822static enum GNUNET_GenericReturnValue
823block_open_ecdsa (void *cls,
824 const char *label,
825 const struct GNUNET_GNSRECORD_Block *block,
826 GNUNET_GNSRECORD_RecordCallback proc,
827 void *proc_cls)
828{
829 struct EncryptionContextData *ecd = cls;
830 enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
831 char *norm_label;
832
833 norm_label = GNUNET_GNSRECORD_string_normalize (label);
834 return block_decrypt_ecdsa (block,
835 &ecd->zkey.ecdsa_key,
836 norm_label, proc,
837 proc_cls);
838 GNUNET_free (norm_label);
839 return res;
840
841}
842
843
844static enum GNUNET_GenericReturnValue
845block_open_eddsa (void *cls,
846 const char *label,
847 const struct GNUNET_GNSRECORD_Block *block,
848 GNUNET_GNSRECORD_RecordCallback proc,
849 void *proc_cls)
850{
851 struct EncryptionContextData *ecd = cls;
852 enum GNUNET_GenericReturnValue res;
853 char *norm_label;
854
855 norm_label = GNUNET_GNSRECORD_string_normalize (label);
856 res = block_decrypt_eddsa (block,
857 &ecd->zkey.eddsa_key,
858 norm_label, proc,
859 proc_cls);
860 GNUNET_free (norm_label);
861 return res;
862}
863
864
865static enum GNUNET_GenericReturnValue
866block_seal_not_implemented (void *cls,
867 const char *label,
868 struct GNUNET_TIME_Absolute expire,
869 unsigned char *rdata,
870 size_t rdata_len,
871 struct GNUNET_GNSRECORD_Block **result)
872{
873 GNUNET_break (0);
874 return GNUNET_SYSERR;
875}
876
877
878static enum GNUNET_GenericReturnValue
879block_seal (void *cls,
880 const char *label,
881 struct GNUNET_TIME_Absolute expire,
882 unsigned char *rdata,
883 size_t rdata_len,
884 struct GNUNET_GNSRECORD_Block **result)
885{
886 struct EncryptionContextData *ecd = cls;
887
888 return block_create2 (ecd->sk,
889 expire,
890 label,
891 rdata,
892 rdata_len,
893 result,
894 GNUNET_YES);
895}
896
897
898struct GNUNET_GNSRECORD_EncryptionContext*
899GNUNET_GNSRECORD_encryption_context_setup_owner (
900 const struct GNUNET_CRYPTO_BlindablePrivateKey *sk)
901{
902 struct GNUNET_GNSRECORD_EncryptionContext *ec;
903 struct EncryptionContextData *ecd;
904 size_t sk_len;
905
906 ec = GNUNET_malloc (sizeof(*ec) + sizeof(struct EncryptionContextData));
907 ec->cls = &ec[1];
908 ecd = ec->cls;
909 sk_len = GNUNET_CRYPTO_blindable_sk_get_length (sk);
910 ecd->sk = GNUNET_malloc (sk_len);
911 GNUNET_memcpy (ecd->sk,
912 sk,
913 sk_len);
914 GNUNET_CRYPTO_blindable_key_get_public (ecd->sk, &ecd->zkey);
915 switch (ntohl (sk->type))
916 {
917 case GNUNET_PUBLIC_KEY_TYPE_ECDSA:
918 ec->open = block_open_ecdsa;
919 ec->seal = block_seal;
920 break;
921 case GNUNET_PUBLIC_KEY_TYPE_EDDSA:
922 ec->open = block_open_eddsa;
923 ec->seal = block_seal;
924 break;
925 default:
926 GNUNET_assert (0);
927 }
928 return ec;
929}
930
931
932struct GNUNET_GNSRECORD_EncryptionContext*
933GNUNET_GNSRECORD_encryption_context_setup_resolver (
934 const struct GNUNET_CRYPTO_BlindablePublicKey *zkey)
935{
936 struct GNUNET_GNSRECORD_EncryptionContext *ec;
937 struct EncryptionContextData *ecd;
938 size_t pk_len;
939
940 ec = GNUNET_malloc (sizeof (*ec) + sizeof (*ecd));
941 ec->cls = &ec[1];
942 ecd = ec->cls;
943 pk_len = GNUNET_CRYPTO_blindable_pk_get_length (zkey);
944 GNUNET_memcpy (&ecd->zkey,
945 zkey,
946 pk_len);
947 switch (ntohl (zkey->type))
948 {
949 case GNUNET_PUBLIC_KEY_TYPE_ECDSA:
950 ec->open = block_open_ecdsa;
951 ec->seal = block_seal_not_implemented;
952 break;
953 case GNUNET_PUBLIC_KEY_TYPE_EDDSA:
954 ec->open = block_open_eddsa;
955 ec->seal = block_seal_not_implemented;
956 break;
957 default:
958 GNUNET_assert (0);
959 }
960 return ec;
961}
962
963
964void
965GNUNET_GNSRECORD_encryption_context_destroy (struct
966 GNUNET_GNSRECORD_EncryptionContext
967 *ec)
968{
969 struct EncryptionContextData *ecd = ec->cls;
970
971 GNUNET_free (ecd->sk);
972 GNUNET_free (ec);
973
974}
975
976
977enum GNUNET_GenericReturnValue
978GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block,
979 const struct
980 GNUNET_CRYPTO_BlindablePublicKey *zone_key,
981 const char *label,
982 GNUNET_GNSRECORD_RecordCallback proc,
983 void *proc_cls)
984{
985 struct GNUNET_GNSRECORD_EncryptionContext *ec;
986 enum GNUNET_GenericReturnValue ret;
987
988 ec = GNUNET_GNSRECORD_encryption_context_setup_resolver (zone_key);
989 ret = ec->open (ec->cls,
990 label,
991 block,
992 proc,
993 proc_cls);
994 GNUNET_GNSRECORD_encryption_context_destroy (ec);
995 return ret;
996}
997
998
999/* end of gnsrecord_crypto.c */
block_sign_ecdsa
static enum GNUNET_GenericReturnValue block_sign_ecdsa(const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey, const char *label, struct GNUNET_GNSRECORD_Block *block)
Definition gnsrecord_crypto.c:99
block_open_eddsa
static enum GNUNET_GenericReturnValue block_open_eddsa(void *cls, const char *label, const struct GNUNET_GNSRECORD_Block *block, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Definition gnsrecord_crypto.c:845
block_seal_not_implemented
static enum GNUNET_GenericReturnValue block_seal_not_implemented(void *cls, const char *label, struct GNUNET_TIME_Absolute expire, unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **result)
Definition gnsrecord_crypto.c:866
block_create_ecdsa
static enum GNUNET_GenericReturnValue block_create_ecdsa(const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey, struct GNUNET_TIME_Absolute expire, const char *label, const unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **block, int sign)
Sign name and records.
Definition gnsrecord_crypto.c:223
block_seal
static enum GNUNET_GenericReturnValue block_seal(void *cls, const char *label, struct GNUNET_TIME_Absolute expire, unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **result)
Definition gnsrecord_crypto.c:879
block_open_ecdsa
static enum GNUNET_GenericReturnValue block_open_ecdsa(void *cls, const char *label, const struct GNUNET_GNSRECORD_Block *block, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Definition gnsrecord_crypto.c:823
block_create2
static enum GNUNET_GenericReturnValue block_create2(const struct GNUNET_CRYPTO_BlindablePrivateKey *pkey, struct GNUNET_TIME_Absolute expire, const char *label, const unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **result, int sign)
Definition gnsrecord_crypto.c:350
GNR_derive_block_aes_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)
We disable deprecation warnings because we implement RFC9408/LSD0001 record types here.
Definition gnsrecord_crypto.c:41
block_sign_eddsa
static enum GNUNET_GenericReturnValue block_sign_eddsa(const struct GNUNET_CRYPTO_EddsaPrivateKey *key, const struct GNUNET_CRYPTO_EddsaPublicKey *pkey, const char *label, struct GNUNET_GNSRECORD_Block *block)
Definition gnsrecord_crypto.c:140
block_decrypt_eddsa
static enum GNUNET_GenericReturnValue block_decrypt_eddsa(const struct GNUNET_GNSRECORD_Block *block, const struct GNUNET_CRYPTO_EddsaPublicKey *zone_key, const char *label, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Definition gnsrecord_crypto.c:595
CSIZE
#define CSIZE
GNR_derive_block_xsalsa_key
void GNR_derive_block_xsalsa_key(struct GNUNET_CRYPTO_XSalsa20Nonce *nonce, struct GNUNET_CRYPTO_XSalsa20SecretKey *key, const char *label, uint64_t exp, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Derive session key and iv from label and public key.
Definition gnsrecord_crypto.c:70
block_decrypt_ecdsa
static enum GNUNET_GenericReturnValue block_decrypt_ecdsa(const struct GNUNET_GNSRECORD_Block *block, const struct GNUNET_CRYPTO_EcdsaPublicKey *zone_key, const char *label, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Definition gnsrecord_crypto.c:465
block_create_eddsa
static enum GNUNET_GenericReturnValue block_create_eddsa(const struct GNUNET_CRYPTO_EddsaPrivateKey *key, const struct GNUNET_CRYPTO_EddsaPublicKey *pkey, struct GNUNET_TIME_Absolute expire, const char *label, const unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **block, int sign)
Sign name and records (EDDSA version)
Definition gnsrecord_crypto.c:286
gnsrecord_crypto.h
API for GNS record-related crypto.
GNUNET_GNSRECORD_TYPE_PKEY
#define GNUNET_GNSRECORD_TYPE_PKEY
WARNING: This header is generated! In order to add GNS record types, you must register them in GANA,...
Definition gnu_name_system_record_types.h:43
GNUNET_GNSRECORD_TYPE_EDKEY
#define GNUNET_GNSRECORD_TYPE_EDKEY
GNS zone delegation (EDKEY)
Definition gnu_name_system_record_types.h:157
ret
static int ret
Final status code.
Definition gnunet-arm.c:93
line
static char * line
Desired phone line (string to be converted to a hash).
Definition gnunet-conversation.c:155
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition gnunet-dht-put.c:37
expire
static char * expire
DID Document expiration Date Attribute String.
Definition gnunet-did.c:98
pkey
static char * pkey
Public key of the zone to look in, in ASCII.
Definition gnunet-namecache.c:58
rd_count
static unsigned int rd_count
Number of records for currently parsed set.
Definition gnunet-namestore-zonefile.c:241
res
static char * res
Currently read line or NULL on EOF.
Definition gnunet-namestore-zonefile.c:256
rd
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
Definition gnunet-namestore-zonefile.c:226
result
static int result
Global testing status.
Definition gnunet-regex-profiler.c:240
pub
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition gnunet-scrypt.c:47
payload
static unsigned long long payload
How much data are we currently storing in the database?
Definition gnunet-service-datastore.c:183
GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN
#define GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN
GNS record set signature (GNS)
Definition gnunet_signatures.h:124
GNUNET_CRYPTO_ecdsa_public_key_derive
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.
Definition crypto_ecc_gnsrecord.c:238
GNUNET_CRYPTO_eddsa_verify_
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_SignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Verify EdDSA signature.
Definition crypto_ecc.c:729
GNUNET_CRYPTO_eddsa_key_get_public
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition crypto_ecc.c:202
GNUNET_CRYPTO_eddsa_public_key_derive
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.
Definition crypto_ecc_gnsrecord.c:343
GNUNET_CRYPTO_aes_ctr
void GNUNET_CRYPTO_aes_ctr(const void *in_buf, size_t in_buf_len, const unsigned char key[(256/8)], const unsigned char iv[(128/8)], void *out_buf)
Decrypt or encrypt a given block using a symmetric key using AES in counter mode.
GNUNET_CRYPTO_ecdsa_key_get_public
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Derive key.
Definition crypto_ecc.c:191
GNUNET_CRYPTO_xsalsa20poly1305_decrypt
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_xsalsa20poly1305_decrypt(size_t in_buf_len, const unsigned char in_buf[in_buf_len], const struct GNUNET_CRYPTO_XSalsa20SecretKey *key, const struct GNUNET_CRYPTO_XSalsa20Nonce *nonce, void *out_buf)
Encrypt the given data using XSalsa20-Poly1305.
Definition crypto_symmetric.c:197
GNUNET_CRYPTO_xsalsa20poly1305_encrypt
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_xsalsa20poly1305_encrypt(size_t in_buf_len, const unsigned char in_buf[in_buf_len], const struct GNUNET_CRYPTO_XSalsa20SecretKey *key, const struct GNUNET_CRYPTO_XSalsa20Nonce *nonce, void *out_buf)
Encrypt the given data using XSalsa20-Poly1305.
Definition crypto_symmetric.c:224
GNUNET_CRYPTO_ecdsa_verify_
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_SignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition crypto_ecc.c:670
GNUNET_GNSRECORD_query_from_private_key
void GNUNET_GNSRECORD_query_from_private_key(const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, struct GNUNET_HashCode *query)
Calculate the DHT query for a given label in a given zone.
Definition gnsrecord_crypto.c:743
GNUNET_GNSRECORD_MAX_BLOCK_SIZE
#define GNUNET_GNSRECORD_MAX_BLOCK_SIZE
Maximum size of a value that can be stored in a GNS block.
Definition gnunet_gnsrecord_lib.h:60
GNUNET_GNSRECORD_records_deserialize
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
Definition gnsrecord_serialization.c:246
GNUNET_GNSRECORD_encryption_context_destroy
void GNUNET_GNSRECORD_encryption_context_destroy(struct GNUNET_GNSRECORD_EncryptionContext *ec)
Cleanup and free the encryption context.
Definition gnsrecord_crypto.c:965
GNUNET_GNSRECORD_encryption_context_setup_resolver
struct GNUNET_GNSRECORD_EncryptionContext * GNUNET_GNSRECORD_encryption_context_setup_resolver(const struct GNUNET_CRYPTO_BlindablePublicKey *zkey)
Create a new encryption context for a resolver.
Definition gnsrecord_crypto.c:933
GNUNET_GNSRECORD_block_verify
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_verify(const struct GNUNET_GNSRECORD_Block *block)
Check if a signature is valid.
Definition gnsrecord_crypto.c:418
GNUNET_GNSRECORD_block_decrypt
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_decrypt(const struct GNUNET_GNSRECORD_Block *block, const struct GNUNET_CRYPTO_BlindablePublicKey *zone_key, const char *label, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Decrypt block.
Definition gnsrecord_crypto.c:978
GNUNET_GNSRECORD_records_deserialize_get_size
unsigned int GNUNET_GNSRECORD_records_deserialize_get_size(size_t len, const char *src)
Definition gnsrecord_serialization.c:200
GNUNET_GNSRECORD_RecordCallback
void(* GNUNET_GNSRECORD_RecordCallback)(void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Process a records that were decrypted from a block.
Definition gnunet_gnsrecord_lib.h:389
GNUNET_GNSRECORD_block_sign
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_sign(const struct GNUNET_CRYPTO_BlindablePrivateKey *key, const char *label, struct GNUNET_GNSRECORD_Block *block)
Sign a block create with GNUNET_GNSRECORD_block_create_unsigned.
Definition gnsrecord_crypto.c:174
GNUNET_GNSRECORD_query_from_public_key
void GNUNET_GNSRECORD_query_from_public_key(const struct GNUNET_CRYPTO_BlindablePublicKey *pub, const char *label, struct GNUNET_HashCode *query)
Calculate the DHT query for a given label in a given zone.
Definition gnsrecord_crypto.c:774
GNUNET_GNSRECORD_encryption_context_setup_owner
struct GNUNET_GNSRECORD_EncryptionContext * GNUNET_GNSRECORD_encryption_context_setup_owner(const struct GNUNET_CRYPTO_BlindablePrivateKey *sk)
Create a new encryption context for the zone owner.
Definition gnsrecord_crypto.c:899
GNUNET_GNSRECORD_string_normalize
char * GNUNET_GNSRECORD_string_normalize(const char *src)
Normalize a UTF-8 string to a GNS name.
Definition gnsrecord_misc.c:36
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
Definition gnunet_gnsrecord_lib.h:132
GNUNET_GNSRECORD_RF_SHADOW
@ GNUNET_GNSRECORD_RF_SHADOW
This record should not be used unless all (other) records in the set with an absolute expiration time...
Definition gnunet_gnsrecord_lib.h:116
GNUNET_CRYPTO_hash
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition crypto_hash.c:40
GNUNET_CRYPTO_hkdf_gnunet
#define GNUNET_CRYPTO_hkdf_gnunet(result, out_len, xts, xts_len, skm, skm_len,...)
A peculiar HKDF instantiation that tried to mimic Truncated NMAC.
Definition gnunet_crypto_lib.h:1593
GNUNET_CRYPTO_blindable_key_get_public
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_blindable_key_get_public(const struct GNUNET_CRYPTO_BlindablePrivateKey *privkey, struct GNUNET_CRYPTO_BlindablePublicKey *key)
Retrieves the public key representation of a private key.
Definition crypto_pkey.c:457
GNUNET_log
#define GNUNET_log(kind,...)
Definition gnunet_common.h:551
GNUNET_NZL
#define GNUNET_NZL(l)
Macro used to avoid using 0 for the length of a variable-size array (Non-Zero-Length).
Definition gnunet_common.h:235
GNUNET_CRYPTO_kdf_arg_string
#define GNUNET_CRYPTO_kdf_arg_string(d)
Definition gnunet_crypto_lib.h:1504
GNUNET_CRYPTO_ecdsa_sign_derived
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_sign_derived(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_SignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
This is a signature function for ECDSA which takes a private key, derives/blinds it and signs the mes...
Definition crypto_ecc_gnsrecord.c:179
GNUNET_CRYPTO_AES_KEY_LENGTH
#define GNUNET_CRYPTO_AES_KEY_LENGTH
length of the sessionkey in bytes
Definition gnunet_crypto_lib.h:84
GNUNET_CRYPTO_eddsa_sign_derived
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_derived(const struct GNUNET_CRYPTO_EddsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_SignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
This is a signature function for EdDSA which takes a private key and derives it using the label and c...
Definition crypto_ecc_gnsrecord.c:74
GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition gnunet_common.h:1320
GNUNET_CRYPTO_blindable_sk_get_length
ssize_t GNUNET_CRYPTO_blindable_sk_get_length(const struct GNUNET_CRYPTO_BlindablePrivateKey *key)
Get the compacted length of a GNUNET_CRYPTO_BlindablePrivateKey.
Definition crypto_pkey.c:66
GNUNET_GenericReturnValue
GNUNET_GenericReturnValue
Named constants for return values.
Definition gnunet_common.h:111
GNUNET_CRYPTO_blindable_pk_get_length
ssize_t GNUNET_CRYPTO_blindable_pk_get_length(const struct GNUNET_CRYPTO_BlindablePublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_BlindablePublicKey.
Definition crypto_pkey.c:87
GNUNET_PUBLIC_KEY_TYPE_EDDSA
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
Definition gnunet_crypto_lib.h:369
GNUNET_PUBLIC_KEY_TYPE_ECDSA
@ GNUNET_PUBLIC_KEY_TYPE_ECDSA
The identity type.
Definition gnunet_crypto_lib.h:363
GNUNET_OK
@ GNUNET_OK
Definition gnunet_common.h:114
GNUNET_YES
@ GNUNET_YES
Definition gnunet_common.h:116
GNUNET_NO
@ GNUNET_NO
Definition gnunet_common.h:113
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:112
GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition gnunet_common.h:1067
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition gnunet_common.h:960
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Definition gnunet_common.h:1045
GNUNET_ERROR_TYPE_INFO
@ GNUNET_ERROR_TYPE_INFO
Definition gnunet_common.h:423
GNUNET_malloc
#define GNUNET_malloc(size)
Wrapper around malloc.
Definition gnunet_common.h:1355
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition gnunet_common.h:1415
GNUNET_TIME_absolute_get
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition time.c:111
GNUNET_TIME_absolute_hton
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition time.c:636
GNUNET_STRINGS_absolute_time_to_string
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition strings.c:671
size
static unsigned int size
Size of the "table".
Definition peer.c:68
EncryptionContextData::sk
struct GNUNET_CRYPTO_BlindablePrivateKey * sk
Definition gnsrecord_crypto.c:817
EncryptionContextData::zkey
struct GNUNET_CRYPTO_BlindablePublicKey zkey
Definition gnsrecord_crypto.c:819
GNRBlockPS
Information we have in an encrypted block with record data (i.e.
Definition gnsrecord_crypto.h:39
GNRBlockPS::expiration_time
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time of the block.
Definition gnsrecord_crypto.h:49
GNRBlockPS::purpose
struct GNUNET_CRYPTO_SignaturePurpose purpose
Number of bytes signed; also specifies the number of bytes of encrypted data that follow.
Definition gnsrecord_crypto.h:44
GNUNET_CRYPTO_BlindablePrivateKey
A private key for an identity as per LSD0001.
Definition gnunet_crypto_lib.h:389
GNUNET_CRYPTO_BlindablePrivateKey::type
uint32_t type
Type of public key.
Definition gnunet_crypto_lib.h:395
GNUNET_CRYPTO_BlindablePublicKey
An identity key as per LSD0001.
Definition gnunet_crypto_lib.h:416
GNUNET_CRYPTO_BlindablePublicKey::type
uint32_t type
Type of public key.
Definition gnunet_crypto_lib.h:422
GNUNET_CRYPTO_BlindablePublicKey::ecdsa_key
struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_key
An ECDSA identity key.
Definition gnunet_crypto_lib.h:429
GNUNET_CRYPTO_BlindablePublicKey::eddsa_key
struct GNUNET_CRYPTO_EddsaPublicKey eddsa_key
AN EdDSA identtiy key.
Definition gnunet_crypto_lib.h:434
GNUNET_CRYPTO_EcdsaPrivateKey
Private ECC key encoded for transmission.
Definition gnunet_crypto_lib.h:244
GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition gnunet_crypto_lib.h:195
GNUNET_CRYPTO_EddsaPrivateKey
Private ECC key encoded for transmission.
Definition gnunet_crypto_lib.h:256
GNUNET_CRYPTO_EddsaPublicKey
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
Definition gnunet_crypto_lib.h:180
GNUNET_CRYPTO_SignaturePurpose::purpose
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Definition gnunet_crypto_lib.h:134
GNUNET_CRYPTO_SignaturePurpose::size
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
Definition gnunet_crypto_lib.h:126
GNUNET_CRYPTO_XSalsa20Nonce
type for session keys
Definition gnunet_crypto_lib.h:977
GNUNET_CRYPTO_XSalsa20Nonce::nonce
unsigned char nonce[24]
Initialization vector.
Definition gnunet_crypto_lib.h:981
GNUNET_CRYPTO_XSalsa20SecretKey
type for session keys
Definition gnunet_crypto_lib.h:964
GNUNET_GNSRECORD_Block
Definition gnunet_gnsrecord_lib.h:284
GNUNET_GNSRECORD_Block::type
uint32_t type
The zone type (GNUNET_GNSRECORD_TYPE_PKEY)
Definition gnunet_gnsrecord_lib.h:293
GNUNET_GNSRECORD_Block::ecdsa_block
struct GNUNET_GNSRECORD_EcdsaBlock ecdsa_block
Definition gnunet_gnsrecord_lib.h:297
GNUNET_GNSRECORD_Block::eddsa_block
struct GNUNET_GNSRECORD_EddsaBlock eddsa_block
Definition gnunet_gnsrecord_lib.h:298
GNUNET_GNSRECORD_Block::size
uint32_t size
Size of the block.
Definition gnunet_gnsrecord_lib.h:288
GNUNET_GNSRECORD_Data
A GNS record.
Definition gnunet_gnsrecord_lib.h:177
GNUNET_GNSRECORD_Data::flags
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
Definition gnunet_gnsrecord_lib.h:205
GNUNET_GNSRECORD_Data::expiration_time
uint64_t expiration_time
Expiration time for the DNS record.
Definition gnunet_gnsrecord_lib.h:190
GNUNET_GNSRECORD_EcdsaBlock
Information we have in an encrypted block with record data (i.e.
Definition gnunet_gnsrecord_lib.h:238
GNUNET_GNSRECORD_EcdsaBlock::signature
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature of the block.
Definition gnunet_gnsrecord_lib.h:247
GNUNET_GNSRECORD_EcdsaBlock::expiration_time
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time of the block.
Definition gnunet_gnsrecord_lib.h:252
GNUNET_GNSRECORD_EcdsaBlock::derived_key
struct GNUNET_CRYPTO_EcdsaPublicKey derived_key
Derived key used for signing; hash of this is the query.
Definition gnunet_gnsrecord_lib.h:242
GNUNET_GNSRECORD_EddsaBlock
Information we have in an encrypted block with record data (i.e.
Definition gnunet_gnsrecord_lib.h:262
GNUNET_GNSRECORD_EddsaBlock::derived_key
struct GNUNET_CRYPTO_EddsaPublicKey derived_key
Derived key used for signing; hash of this is the query.
Definition gnunet_gnsrecord_lib.h:266
GNUNET_GNSRECORD_EddsaBlock::expiration_time
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time of the block.
Definition gnunet_gnsrecord_lib.h:276
GNUNET_GNSRECORD_EddsaBlock::signature
struct GNUNET_CRYPTO_EddsaSignature signature
Signature of the block.
Definition gnunet_gnsrecord_lib.h:271
GNUNET_GNSRECORD_EncryptionContext
The GNSRECORD encryption context.
Definition gnunet_gnsrecord_lib.h:719
GNUNET_GNSRECORD_EncryptionContext::open
enum GNUNET_GenericReturnValue(* open)(void *cls, const char *label, const struct GNUNET_GNSRECORD_Block *block, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
Open a record set.
Definition gnunet_gnsrecord_lib.h:759
GNUNET_GNSRECORD_EncryptionContext::cls
void * cls
Private data of the context.
Definition gnunet_gnsrecord_lib.h:724
GNUNET_GNSRECORD_EncryptionContext::seal
enum GNUNET_GenericReturnValue(* seal)(void *cls, const char *label, struct GNUNET_TIME_Absolute expire, unsigned char *rdata, size_t rdata_len, struct GNUNET_GNSRECORD_Block **result)
Seal a record set.
Definition gnunet_gnsrecord_lib.h:739
GNUNET_HashCode
A 512-bit hashcode.
Definition gnunet_common.h:287
GNUNET_TIME_AbsoluteNBO::abs_value_us__
uint64_t abs_value_us__
The actual value (in network byte order).
Definition gnunet_time_lib.h:111
GNUNET_TIME_Absolute
Time for absolute times used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:54
GNUNET_TIME_Absolute::abs_value_us
uint64_t abs_value_us
The actual value.
Definition gnunet_time_lib.h:59
KeyCacheLine
Line in cache mapping private keys to public keys.
Definition gnsrecord_crypto.c:337
KeyCacheLine::pkey
struct GNUNET_CRYPTO_EcdsaPublicKey pkey
Associated public key.
Definition gnsrecord_crypto.c:346
KeyCacheLine::key
struct GNUNET_CRYPTO_EcdsaPrivateKey key
A private key.
Definition gnsrecord_crypto.c:341