GNUnet  0.11.x
gnunet-abd.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012-2013 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 */
25 #include "platform.h"
26 #include <gnunet_util_lib.h>
27 #include <gnunet_abd_service.h>
28 #include <gnunet_gnsrecord_lib.h>
30 #include "delegate_misc.h"
31 #include "abd_serialization.h"
32 
36 static const struct GNUNET_CONFIGURATION_Handle *cfg;
37 
41 static struct GNUNET_NAMESTORE_Handle *ns;
42 
47 
52 
56 static struct GNUNET_ABD_Handle *abd;
57 
62 
67 
72 
76 static struct GNUNET_SCHEDULER_Task *tt;
77 
81 static int ret = 0;
82 
86 static char *subject;
87 
91 static char *subject_delegate;
92 
96 static char *expiration;
97 
102 
107 
108 
112 static char *issuer_key;
113 
117 static char *ego_name;
118 
122 static char *issuer_attr;
123 
127 static int verify;
128 
132 static int collect;
133 
137 static int create_is;
138 
142 static int create_ss;
143 
147 static int sign_ss;
148 
152 static char *import;
153 
157 static int is_private;
158 
162 static int forward;
163 
167 static int backward;
168 
173 
178 
182 static void *data;
183 
187 static size_t data_size;
188 
192 static uint32_t type;
193 
197 static char *typestring;
201 static uint64_t etime;
202 
207 
211 static const int key_length = 52;
212 
216 static char *record_label;
217 
223 static void
224 do_shutdown (void *cls)
225 {
226  if (NULL != verify_request)
227  {
228  GNUNET_ABD_request_cancel (verify_request);
229  verify_request = NULL;
230  }
231  if (NULL != abd)
232  {
233  GNUNET_ABD_disconnect (abd);
234  abd = NULL;
235  }
236  if (NULL != tt)
237  {
239  tt = NULL;
240  }
241  if (NULL != el)
242  {
244  el = NULL;
245  }
246  if (NULL != add_qe)
247  {
248  GNUNET_NAMESTORE_cancel (add_qe);
249  add_qe = NULL;
250  }
251  if (NULL != ns)
252  {
254  ns = NULL;
255  }
256 }
257 
258 
264 static void
265 do_timeout (void *cls)
266 {
267  tt = NULL;
269 }
270 
271 static void
273  struct GNUNET_ABD_Delegation *dd,
274  bool is_bw)
275 {
276  char *prefix = "";
277  if(is_bw)
278  prefix = "Backward -";
279  else
280  prefix = "Forward -";
281 
282  printf ("%s Intermediate result: %s.%s <- %s.%s\n",
283  prefix,
285  dd->issuer_attribute,
287  dd->subject_attribute);
288 }
289 
290 static void
292  unsigned int d_count,
293  struct GNUNET_ABD_Delegation *dc,
294  unsigned int c_count,
295  struct GNUNET_ABD_Delegate *dele)
296 {
297  int i;
298  char *line;
299 
300  verify_request = NULL;
301  if (NULL != dele)
302  {
303  for (i = 0; i < c_count; i++)
304  {
305  line = GNUNET_ABD_delegate_to_string (&dele[i]);
306  printf ("%s\n", line);
307  GNUNET_free (line);
308  }
309  }
310  else
311  {
312  printf ("Received NULL\n");
313  }
314 
316 }
317 
318 
319 static void
321  unsigned int d_count,
322  struct GNUNET_ABD_Delegation *dc,
323  unsigned int c_count,
324  struct GNUNET_ABD_Delegate *dele)
325 {
326  int i;
327  char *iss_key;
328  char *sub_key;
329 
330  verify_request = NULL;
331  if (NULL == dele)
332  ret = 1;
333  else
334  {
335  printf ("Delegation Chain:\n");
336  for (i = 0; i < d_count; i++)
337  {
339  sub_key = GNUNET_CRYPTO_ecdsa_public_key_to_string (&dc[i].subject_key);
340 
341  if (0 != dc[i].subject_attribute_len)
342  {
343  printf ("(%d) %s.%s <- %s.%s\n",
344  i,
345  iss_key,
346  dc[i].issuer_attribute,
347  sub_key,
348  dc[i].subject_attribute);
349  }
350  else
351  {
352  printf ("(%d) %s.%s <- %s\n",
353  i,
354  iss_key,
355  dc[i].issuer_attribute,
356  sub_key);
357  }
358  GNUNET_free (iss_key);
359  GNUNET_free (sub_key);
360  }
361  printf ("\nDelegate(s):\n");
362  for (i = 0; i < c_count; i++)
363  {
365  sub_key = GNUNET_CRYPTO_ecdsa_public_key_to_string (&dele[i].subject_key);
366  printf ("%s.%s <- %s\n", iss_key, dele[i].issuer_attribute, sub_key);
367  GNUNET_free (iss_key);
368  GNUNET_free (sub_key);
369  }
370  printf ("Successful.\n");
371  }
372 
374 }
375 
383 static void
384 identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
385 {
386  const struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey;
387 
388  el = NULL;
389  if (NULL == ego)
390  {
391  if (NULL != ego_name)
392  {
393  fprintf (stderr,
394  _ ("Ego `%s' not known to identity service\n"),
395  ego_name);
396  }
398  return;
399  }
400 
401  if (GNUNET_YES == collect)
402  {
403 
404  if (GNUNET_OK !=
406  strlen (issuer_key),
407  &issuer_pkey))
408  {
409  fprintf (stderr,
410  _ ("Issuer public key `%s' is not well-formed\n"),
411  issuer_key);
413  }
414  privkey = GNUNET_IDENTITY_ego_get_private_key (ego);
415 
416  collect_request = GNUNET_ABD_collect (abd,
417  &issuer_pkey,
418  issuer_attr,
419  privkey,
420  direction,
422  NULL,
424  NULL);
425  return;
426  }
428 }
429 
438 static int
440  int *etime_is_rel,
441  uint64_t *etime)
442 {
443  // copied from namestore/gnunet-namestore.c
444  struct GNUNET_TIME_Relative etime_rel;
445  struct GNUNET_TIME_Absolute etime_abs;
446 
447  if (0 == strcmp (expirationstring, "never"))
448  {
449  *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
450  *etime_is_rel = GNUNET_NO;
451  return GNUNET_OK;
452  }
453  if (GNUNET_OK ==
454  GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
455  {
456  *etime_is_rel = GNUNET_YES;
457  *etime = etime_rel.rel_value_us;
459  "Storing record with relative expiration time of %s\n",
461  return GNUNET_OK;
462  }
463  if (GNUNET_OK ==
464  GNUNET_STRINGS_fancy_time_to_absolute (expirationstring, &etime_abs))
465  {
466  *etime_is_rel = GNUNET_NO;
467  *etime = etime_abs.abs_value_us;
469  "Storing record with absolute expiration time of %s\n",
471  return GNUNET_OK;
472  }
473  return GNUNET_SYSERR;
474 }
475 
479 static void
480 error_cb (void *cls)
481 {
482  fprintf (stderr, "Error occured during lookup, shutting down.\n");
484  return;
485 }
486 static void
487 add_continuation (void *cls, int32_t success, const char *emsg)
488 {
489  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
490  *qe = NULL;
491 
492  if(GNUNET_OK == success)
493  printf ("Adding successful.\n");
494  else
495  fprintf (stderr, "Error occured during adding, shutting down.\n");
496 
498 }
499 
500 static void
502  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
503  const char *rec_name,
504  unsigned int rd_count,
505  const struct GNUNET_GNSRECORD_Data *rd)
506 {
507  struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
508  struct GNUNET_GNSRECORD_Data *rde;
509 
510  memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
511  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
512  rde = &rdn[0];
513  rde->data = data;
514  rde->data_size = data_size;
515  rde->record_type = type;
516 
517  // Set flags
518  if (GNUNET_YES == is_private)
520  rde->expiration_time = etime;
521  if (GNUNET_YES == etime_is_rel)
523  else if (GNUNET_NO != etime_is_rel)
524  rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
525 
526  GNUNET_assert (NULL != rec_name);
527  add_qe = GNUNET_NAMESTORE_records_store (ns,
528  &zone_pkey,
529  rec_name,
530  rd_count + 1,
531  rde,
533  &add_qe);
534 
535  return;
536 }
537 
538 static void
539 store_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
540 {
541  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
542 
543  el = NULL;
544 
545  ns = GNUNET_NAMESTORE_connect (cfg);
546  if (NULL == ns)
547  {
549  _ ("Failed to connect to namestore\n"));
551  return;
552  }
553 
554  // Key handling
556 
558  {
559  // Parse import
560  struct GNUNET_ABD_Delegate *cred;
561  cred = GNUNET_ABD_delegate_from_string (import);
562 
563  // Get import subject public key string
564  char *subject_pubkey_str =
566 
567  // Get zone public key string
568  struct GNUNET_CRYPTO_EcdsaPublicKey zone_pubkey;
569  GNUNET_IDENTITY_ego_get_public_key (ego, &zone_pubkey);
570  char *zone_pubkey_str =
572 
573  // Check if the subject key in the signed import matches the zone's key it is issued to
574  if (strcmp (zone_pubkey_str, subject_pubkey_str) != 0)
575  {
576  fprintf (stderr,
577  "Import signed delegate does not match this ego's public key.\n");
579  return;
580  }
581 
582  // Expiration
583  etime = cred->expiration.abs_value_us;
585 
586  // Prepare the data to be store in the record
587  data_size = GNUNET_ABD_delegate_serialize (cred, (char **) &data);
588  GNUNET_free (cred);
589  }
590  else
591  {
592  // For all other types e.g. GNUNET_GNSRECORD_TYPE_ATTRIBUTE
593  if (GNUNET_OK !=
595  {
596  fprintf (stderr,
597  "Value `%s' invalid for record type `%s'\n",
598  subject,
599  typestring);
601  return;
602  }
603 
604  // Take care of expiration
605  if (NULL == expiration)
606  {
607  fprintf (stderr, "Missing option -e for operation 'create'\n");
609  return;
610  }
612  {
613  fprintf (stderr, "Invalid time format `%s'\n", expiration);
615  return;
616  }
617  }
618 
619  // Start lookup
620  add_qe = GNUNET_NAMESTORE_records_lookup (ns,
621  &zone_pkey,
622  record_label,
623  &error_cb,
624  NULL,
626  NULL);
627  return;
628 }
629 
630 static void
631 sign_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
632 {
633  const struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey;
634  struct GNUNET_ABD_Delegate *dele;
635  struct GNUNET_TIME_Absolute etime_abs;
636  char *res;
637 
638  el = NULL;
639 
640  // work on expiration time
641  if (NULL == expiration)
642  {
643  fprintf (stderr, "Please specify a TTL\n");
645  return;
646  }
647  else if (GNUNET_OK !=
649  {
650  fprintf (stderr,
651  "%s is not a valid ttl! Only absolute times are accepted!\n",
652  expiration);
654  return;
655  }
656 
657  // If contains a space - split it by the first space only - assume first entry is subject followed by attribute(s)
658  char *subject_pubkey_str;
659  char *subject_attr = NULL;
660  char *token;
661 
662  // Subject Public Key
663  token = strtok (subject, " ");
664  if (key_length == strlen (token))
665  {
666  subject_pubkey_str = token;
667  }
668  else
669  {
670  fprintf (stderr, "Key error, wrong length: %ld!\n", strlen (token));
672  return;
673  }
674  // Subject Attribute(s)
675  token = strtok (NULL, " ");
676  if (NULL != token)
677  {
678  subject_attr = token;
679  }
680 
681  // work on keys
682  privkey = GNUNET_IDENTITY_ego_get_private_key (ego);
683 
684  if (GNUNET_OK !=
685  GNUNET_CRYPTO_ecdsa_public_key_from_string (subject_pubkey_str,
686  strlen (subject_pubkey_str),
687  &subject_pkey))
688  {
689  fprintf (stderr,
690  "Subject public key `%s' is not well-formed\n",
691  subject_pubkey_str);
693  return;
694  }
695 
696  // Sign delegate
697  dele = GNUNET_ABD_delegate_issue (privkey,
698  &subject_pkey,
699  issuer_attr,
700  subject_attr,
701  &etime_abs);
702  res = GNUNET_ABD_delegate_to_string (dele);
703  GNUNET_free (dele);
704  printf ("%s\n", res);
705 
707  ego_name = NULL;
708 
710 }
711 
720 static void
721 run (void *cls,
722  char *const *args,
723  const char *cfgfile,
724  const struct GNUNET_CONFIGURATION_Handle *c)
725 {
726  cfg = c;
727 
730 
731  // Check relevant cmdline parameters
732  if (GNUNET_YES == create_is)
733  {
734  if (NULL == ego_name)
735  {
736  fprintf (stderr, "Missing option '-ego'\n");
738  return;
739  }
740  if (NULL == issuer_attr)
741  {
742  fprintf (stderr, "Missing option '-attribute' for issuer attribute\n");
744  return;
745  }
746  if (NULL == subject)
747  {
748  fprintf (stderr, "Missing option -subject for operation 'create'.'\n");
750  return;
751  }
752 
753  // Lookup ego, on success call store_cb and store as ATTRIBUTE type
756  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &store_cb, (void *) cfg);
757  return;
758  }
759 
760  if (GNUNET_YES == create_ss)
761  {
762 
763  // check if signed parameter has been passed in cmd line call
764  if (NULL == import)
765  {
766  fprintf (stderr, "'import' required\n");
768  return;
769  }
770 
773  // Store subject side
774  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &store_cb, (void *) cfg);
775 
776  return;
777  }
778 
779  if (GNUNET_YES == sign_ss)
780  {
781  if (NULL == ego_name)
782  {
783  fprintf (stderr, "ego required\n");
785  return;
786  }
787  if (NULL == subject)
788  {
789  fprintf (stderr, "Subject public key needed\n");
791  return;
792  }
793 
794  // lookup ego and call function sign_cb on success
795  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &sign_cb, (void *) cfg);
796  return;
797  }
798 
799  if (GNUNET_NO == forward && GNUNET_NO == backward)
800  {
801  // set default: bidirectional
804  }
805  if (GNUNET_YES == forward)
807  if (GNUNET_YES == backward)
809 
810  if (GNUNET_YES == collect)
811  {
812  if (NULL == issuer_key)
813  {
814  fprintf (stderr, _ ("Issuer public key not well-formed\n"));
816  return;
817  }
818 
819  abd = GNUNET_ABD_connect (cfg);
820 
821  if (NULL == abd)
822  {
823  fprintf (stderr, _ ("Failed to connect to ABD\n"));
825  return;
826  }
827  if (NULL == issuer_attr)
828  {
829  fprintf (stderr, _ ("You must provide issuer the attribute\n"));
831  return;
832  }
833 
834  if (NULL == ego_name)
835  {
836  fprintf (stderr, _ ("ego required\n"));
838  return;
839  }
840  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
841  return;
842  }
843 
844  if (NULL == subject)
845  {
846  fprintf (stderr, _ ("Subject public key needed\n"));
848  return;
849  }
851  strlen (subject),
852  &subject_pkey))
853  {
854  fprintf (stderr,
855  _ ("Subject public key `%s' is not well-formed\n"),
856  subject);
858  return;
859  }
860 
861  if (GNUNET_YES == verify)
862  {
863  if (NULL == issuer_key)
864  {
865  fprintf (stderr, _ ("Issuer public key not well-formed\n"));
867  return;
868  }
869  if (GNUNET_OK !=
871  strlen (issuer_key),
872  &issuer_pkey))
873  {
874  fprintf (stderr,
875  _ ("Issuer public key `%s' is not well-formed\n"),
876  issuer_key);
878  return;
879  }
880  abd = GNUNET_ABD_connect (cfg);
881 
882  if (NULL == abd)
883  {
884  fprintf (stderr, _ ("Failed to connect to ABD\n"));
886  return;
887  }
888  if (NULL == issuer_attr || NULL == subject_delegate)
889  {
890  fprintf (stderr, _ ("You must provide issuer and subject attributes\n"));
892  return;
893  }
894 
895  //Subject credentials are comma separated
896  char *tmp = GNUNET_strdup (subject_delegate);
897  char *tok = strtok (tmp, ",");
898  if (NULL == tok)
899  {
900  fprintf (stderr, "Invalid subject credentials\n");
901  GNUNET_free (tmp);
903  return;
904  }
905  int count = 1;
906  int i;
907  while (NULL != (tok = strtok (NULL, ",")))
908  count++;
909  struct GNUNET_ABD_Delegate delegates[count];
910  struct GNUNET_ABD_Delegate *dele;
911  GNUNET_free (tmp);
913  tok = strtok (tmp, ",");
914  for (i = 0; i < count; i++)
915  {
916  dele = GNUNET_ABD_delegate_from_string (tok);
917  GNUNET_memcpy (&delegates[i],
918  dele,
919  sizeof (struct GNUNET_ABD_Delegate));
920  delegates[i].issuer_attribute = GNUNET_strdup (dele->issuer_attribute);
921  tok = strtok (NULL, ",");
922  GNUNET_free (dele);
923  }
924 
925  verify_request = GNUNET_ABD_verify (abd,
926  &issuer_pkey,
927  issuer_attr,
928  &subject_pkey,
929  count,
930  delegates,
931  direction,
933  NULL,
935  NULL);
936  for (i = 0; i < count; i++)
937  {
938  GNUNET_free ((char *) delegates[i].issuer_attribute);
939  }
940  GNUNET_free (tmp);
941  }
942  else
943  {
944  fprintf (stderr,
945  _ (
946  "Please specify name to lookup, subject key and issuer key!\n"));
948  }
949  return;
950 }
951 
952 
960 int
961 main (int argc, char *const *argv)
962 {
963  struct GNUNET_GETOPT_CommandLineOption options[] =
965  "verify",
966  gettext_noop (
967  "verify credential against attribute"),
968  &verify),
970  's',
971  "subject",
972  "PKEY",
973  gettext_noop (
974  "The public key of the subject to lookup the"
975  "credential for, or for issuer side storage: subject and its attributes"),
976  &subject),
978  'd',
979  "delegate",
980  "DELE",
981  gettext_noop ("The private, signed delegate presented by the subject"),
984  'i',
985  "issuer",
986  "PKEY",
987  gettext_noop (
988  "The public key of the authority to verify the credential against"),
989  &issuer_key),
991  "ego",
992  "EGO",
993  gettext_noop ("The ego/zone name to use"),
994  &ego_name),
996  'a',
997  "attribute",
998  "ATTR",
999  gettext_noop ("The issuer attribute to verify against or to issue"),
1000  &issuer_attr),
1002  "ttl",
1003  "EXP",
1004  gettext_noop (
1005  "The time to live for the credential."
1006  "e.g. 5m, 6h, \"1990-12-30 12:00:00\""),
1007  &expiration),
1009  "collect",
1010  gettext_noop ("collect credentials"),
1011  &collect),
1013  "createIssuerSide",
1014  gettext_noop (
1015  "Create and issue a credential issuer side."),
1016  &create_is),
1018  "createSubjectSide",
1019  gettext_noop (
1020  "Issue a credential subject side."),
1021  &create_ss),
1023  'S',
1024  "signSubjectSide",
1025  gettext_noop ("Create, sign and return a credential subject side."),
1026  &sign_ss),
1028  'x',
1029  "import",
1030  "IMP",
1031  gettext_noop (
1032  "Import signed credentials that should be issued to a zone/ego"),
1033  &import),
1035  "private",
1036  gettext_noop ("Create private record entry."),
1037  &is_private),
1039  'F',
1040  "forward",
1041  gettext_noop (
1042  "Indicates that the collect/verify process is done via forward search."),
1043  &forward),
1045  'B',
1046  "backward",
1047  gettext_noop (
1048  "Indicates that the collect/verify process is done via forward search."),
1049  &backward),
1051 
1052 
1054  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1055  return 2;
1056 
1057  GNUNET_log_setup ("gnunet-abd", "WARNING", NULL);
1058  if (GNUNET_OK != GNUNET_PROGRAM_run (argc,
1059  argv,
1060  "gnunet-abd",
1061  _ ("GNUnet abd resolver tool"),
1062  options,
1063  &run,
1064  NULL))
1065  ret = 1;
1066  GNUNET_free ((void *) argv);
1067  return ret;
1068 }
1069 
1070 /* end of gnunet-abd.c */
static void handle_verify_result(void *cls, unsigned int d_count, struct GNUNET_ABD_Delegation *dc, unsigned int c_count, struct GNUNET_ABD_Delegate *dele)
Definition: gnunet-abd.c:320
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
static char * typestring
Type of the record to add/remove, NULL to remove all.
Definition: gnunet-abd.c:197
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
static int create_is
Create mode.
Definition: gnunet-abd.c:137
struct GNUNET_ABD_Handle * GNUNET_ABD_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the ABD service.
Definition: abd_api.c:350
void GNUNET_IDENTITY_ego_lookup_cancel(struct GNUNET_IDENTITY_EgoLookup *el)
Abort ego lookup attempt.
Handle for ego lookup.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint64_t rel_value_us
The actual value.
char * GNUNET_ABD_delegate_to_string(const struct GNUNET_ABD_Delegate *cred)
Definition: delegate_misc.c:37
static void handle_collect_result(void *cls, unsigned int d_count, struct GNUNET_ABD_Delegation *dc, unsigned int c_count, struct GNUNET_ABD_Delegate *dele)
Definition: gnunet-abd.c:291
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
Definition: gnunet-abd.c:76
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
static void error_cb(void *cls)
Function called if lookup fails.
Definition: gnunet-abd.c:480
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1440
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:351
static void handle_intermediate_result(void *cls, struct GNUNET_ABD_Delegation *dd, bool is_bw)
Definition: gnunet-abd.c:272
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:555
GNUNET_ABD_AlgoDirectionFlags
struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, struct GNUNET_CRYPTO_EcdsaPublicKey *subject, const char *iss_attr, const char *sub_attr, struct GNUNET_TIME_Absolute *expiration)
Issue an attribute to a subject.
struct GNUNET_ABD_Request * GNUNET_ABD_collect(struct GNUNET_ABD_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key, enum GNUNET_ABD_AlgoDirectionFlags direction, GNUNET_ABD_CredentialResultProcessor proc, void *proc_cls, GNUNET_ABD_IntermediateResultProcessor proc2, void *proc2_cls)
Performs attribute collection.
Definition: abd_api.c:419
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:402
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_pkey
Issuer key.
Definition: gnunet-abd.c:106
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
size_t data_size
Number of bytes in data.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition of a command line option.
Private ECC key encoded for transmission.
Delegate helper functions.
Handle to a verify request.
Definition: abd_api.c:43
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint64_t abs_value_us
The actual value.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
enum GNUNET_ABD_AlgoDirectionFlags direction
API enum, filled and passed for collect/verify.
Definition: gnunet-abd.c:172
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
static int parse_expiration(const char *expirationstring, int *etime_is_rel, uint64_t *etime)
Parse expiration time.
Definition: gnunet-abd.c:439
static void do_timeout(void *cls)
Task run on timeout.
Definition: gnunet-abd.c:265
int GNUNET_ABD_delegate_serialize(struct GNUNET_ABD_Delegate *dele, char **data)
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
#define GNUNET_GNSRECORD_TYPE_DELEGATE
65546 reserved
static char * record_label
Record label for storing delegations.
Definition: gnunet-abd.c:216
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
Handle for an ego.
Definition: identity.h:245
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
const void * data
Binary value stored in the DNS record.
static char * line
Desired phone line (string to be converted to a hash).
struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_from_string(const char *s)
Definition: delegate_misc.c:79
Connection to the NAMESTORE service.
uint64_t expiration_time
Expiration time for the DNS record.
static char * subject_delegate
Subject delegate string.
Definition: gnunet-abd.c:91
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
static void sign_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
Definition: gnunet-abd.c:631
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
static const int key_length
Fixed size of the public/private keys.
Definition: gnunet-abd.c:211
static int is_private
Is record private.
Definition: gnunet-abd.c:157
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_CRYPTO_EcdsaPublicKey subject_pkey
Subject key.
Definition: gnunet-abd.c:101
This is a private record of this peer and it should thus not be handed out to other peers...
static int forward
Search direction: forward.
Definition: gnunet-abd.c:162
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the delegation.
static void do_shutdown(void *cls)
Task run on shutdown.
Definition: gnunet-abd.c:224
int GNUNET_GNSRECORD_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a &#39;value&#39; of a record to the binary representation.
Definition: gnsrecord.c:175
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static int res
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:332
static char * issuer_key
Issuer pubkey string.
Definition: gnunet-abd.c:112
static int collect
Collect mode.
Definition: gnunet-abd.c:132
Connection to the ABD service.
Definition: abd_api.c:96
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_ABD_Request * collect_request
Handle to collect request.
Definition: gnunet-abd.c:71
static int create_ss
Create mode.
Definition: gnunet-abd.c:142
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
static char * expirationstring
Desired expiration time.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
static struct GNUNET_ABD_Handle * abd
Handle to Credential service.
Definition: gnunet-abd.c:56
static void store_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
Definition: gnunet-abd.c:539
static void * data
Value in binary format.
Definition: gnunet-abd.c:182
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:568
const char * subject_attribute
The attribute.
static int backward
Search direction: backward.
Definition: gnunet-abd.c:167
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
static struct GNUNET_CRYPTO_EcdsaPrivateKey zone_pkey
Private key for the our zone.
Definition: gnunet-abd.c:46
static char * subject
Subject pubkey string.
Definition: gnunet-abd.c:86
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this attribute was delegated to.
void GNUNET_ABD_request_cancel(struct GNUNET_ABD_Request *lr)
Cancel pending verify request.
Definition: abd_api.c:395
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:466
uint32_t record_type
Type of the GNS/DNS record.
configuration data
Definition: configuration.c:85
static struct GNUNET_NAMESTORE_QueueEntry * add_qe
Queue entry for the &#39;add&#39; operation.
Definition: gnunet-abd.c:177
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static struct GNUNET_ABD_Request * verify_request
Handle to verify request.
Definition: gnunet-abd.c:66
static uint32_t type
Type string converted to DNS type value.
Definition: gnunet-abd.c:192
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
#define GNUNET_GNSRECORD_TYPE_ATTRIBUTE
Record type for reverse lookups.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
Definition: gnunet-abd.c:721
int 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, parse options).
Definition: program.c:368
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
static int etime_is_rel
Is expiration time relative or absolute time?
Definition: gnunet-abd.c:206
void GNUNET_ABD_disconnect(struct GNUNET_ABD_Handle *handle)
Shutdown connection with the ABD service.
Definition: abd_api.c:372
const char * issuer_attribute
The attribute.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
This flag is currently unused; former RF_PENDING flag.
const char * issuer_attribute
The issuer attribute.
static uint64_t etime
Expiration string converted to numeric value.
Definition: gnunet-abd.c:201
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:742
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
static int sign_ss
Create mode.
Definition: gnunet-abd.c:147
struct GNUNET_ABD_Request * GNUNET_ABD_verify(struct GNUNET_ABD_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key, uint32_t delegate_count, const struct GNUNET_ABD_Delegate *delegates, enum GNUNET_ABD_AlgoDirectionFlags direction, GNUNET_ABD_CredentialResultProcessor proc, void *proc_cls, GNUNET_ABD_IntermediateResultProcessor proc2, void *proc2_cls)
Performs attribute verification.
Definition: abd_api.c:491
static int verify
Verify mode.
Definition: gnunet-abd.c:127
static struct GNUNET_IDENTITY_EgoLookup * el
EgoLookup.
Definition: gnunet-abd.c:51
static void add_continuation(void *cls, int32_t success, const char *emsg)
Definition: gnunet-abd.c:487
int main(int argc, char *const *argv)
The main function for gnunet-gns.
Definition: gnunet-abd.c:961
API to serialize and deserialize delegation chains and abds.
static char * ego_name
ego
Definition: gnunet-abd.c:117
static char * issuer_attr
Issuer attribute.
Definition: gnunet-abd.c:122
static void get_existing_record(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rec_name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Definition: gnunet-abd.c:501
static struct GNUNET_FS_DownloadContext * dc
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
static void identity_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
Callback invoked from identity service with ego information.
Definition: gnunet-abd.c:384