src/reclaim/gnunet-reclaim.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2012-2015 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  * @author Martin Schanzenbach
  22  * @file src/reclaim/gnunet-reclaim.c
  23  * @brief Identity Provider utility
  24  *
  25  */
  26 #include "platform.h"
  27 #include <inttypes.h>
  28
  29 #include "gnunet_util_lib.h"
  30
  31 #include "gnunet_identity_service.h"
  32 #include "gnunet_namestore_service.h"
  33 #include "gnunet_reclaim_service.h"
  34 #include "gnunet_signatures.h"
  35 /**
  36  * return value
  37  */
  38 static int ret;
  39
  40 /**
  41  * List attribute flag
  42  */
  43 static int list;
  44
  45 /**
  46  * Relying party
  47  */
  48 static char *rp;
  49
  50 /**
  51  * The attribute
  52  */
  53 static char *attr_name;
  54
  55 /**
  56  * Attribute value
  57  */
  58 static char *attr_value;
  59
  60 /**
  61  * Attributes to issue
  62  */
  63 static char *issue_attrs;
  64
  65 /**
  66  * Ticket to consume
  67  */
  68 static char *consume_ticket;
  69
  70 /**
  71  * Attribute type
  72  */
  73 static char *type_str;
  74
  75 /**
  76  * Ticket to revoke
  77  */
  78 static char *revoke_ticket;
  79
  80 /**
  81  * Ticket listing
  82  */
  83 static int list_tickets;
  84
  85 /**
  86  * Ego name
  87  */
  88 static char *ego_name;
  89
  90 /**
  91  * Identity handle
  92  */
  93 static struct GNUNET_IDENTITY_Handle *identity_handle;
  94
  95 /**
  96  * reclaim handle
  97  */
  98 static struct GNUNET_RECLAIM_Handle *reclaim_handle;
  99
 100 /**
 101  * reclaim operation
 102  */
 103 static struct GNUNET_RECLAIM_Operation *reclaim_op;
 104
 105 /**
 106  * Attribute iterator
 107  */
 108 static struct GNUNET_RECLAIM_AttributeIterator *attr_iterator;
 109
 110 /**
 111  * Ticket iterator
 112  */
 113 static struct GNUNET_RECLAIM_TicketIterator *ticket_iterator;
 114
 115 /**
 116  * Master ABE key
 117  */
 118 static struct GNUNET_CRYPTO_AbeMasterKey *abe_key;
 119
 120 /**
 121  * ego private key
 122  */
 123 static const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey;
 124
 125 /**
 126  * rp public key
 127  */
 128 static struct GNUNET_CRYPTO_EcdsaPublicKey rp_key;
 129
 130 /**
 131  * Ticket to consume
 132  */
 133 static struct GNUNET_RECLAIM_Ticket ticket;
 134
 135 /**
 136  * Attribute list
 137  */
 138 static struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attr_list;
 139
 140 /**
 141  * Attribute expiration interval
 142  */
 143 static struct GNUNET_TIME_Relative exp_interval;
 144
 145 /**
 146  * Timeout task
 147  */
 148 static struct GNUNET_SCHEDULER_Task *timeout;
 149
 150 /**
 151  * Cleanup task
 152  */
 153 static struct GNUNET_SCHEDULER_Task *cleanup_task;
 154
 155 /**
 156  * Claim to store
 157  */
 158 struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
 159
 160 /**
 161  * Claim to delete
 162  */
 163 static char *attr_delete;
 164
 165 /**
 166  * Claim object to delete
 167  */
 168 static struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr_to_delete;
 169
 170 static void
 171 do_cleanup(void *cls)
 172 {
 173   cleanup_task = NULL;
 174   if (NULL != timeout)
 175     GNUNET_SCHEDULER_cancel(timeout);
 176   if (NULL != reclaim_op)
 177     GNUNET_RECLAIM_cancel(reclaim_op);
 178   if (NULL != attr_iterator)
 179     GNUNET_RECLAIM_get_attributes_stop(attr_iterator);
 180   if (NULL != ticket_iterator)
 181     GNUNET_RECLAIM_ticket_iteration_stop(ticket_iterator);
 182   if (NULL != reclaim_handle)
 183     GNUNET_RECLAIM_disconnect(reclaim_handle);
 184   if (NULL != identity_handle)
 185     GNUNET_IDENTITY_disconnect(identity_handle);
 186   if (NULL != abe_key)
 187     GNUNET_free(abe_key);
 188   if (NULL != attr_list)
 189     GNUNET_free(attr_list);
 190   if (NULL != attr_to_delete)
 191     GNUNET_free(attr_to_delete);
 192 }
 193
 194 static void
 195 ticket_issue_cb(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 196 {
 197   char *ticket_str;
 198
 199   reclaim_op = NULL;
 200   if (NULL != ticket)
 201     {
 202       ticket_str =
 203         GNUNET_STRINGS_data_to_string_alloc(ticket,
 204                                             sizeof(
 205                                               struct GNUNET_RECLAIM_Ticket));
 206       printf("%s\n", ticket_str);
 207       GNUNET_free(ticket_str);
 208     }
 209   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 210 }
 211
 212 static void
 213 store_attr_cont(void *cls, int32_t success, const char *emsg)
 214 {
 215   reclaim_op = NULL;
 216   if (GNUNET_SYSERR == success)
 217     {
 218       fprintf(stderr, "%s\n", emsg);
 219     }
 220   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 221 }
 222
 223 static void
 224 process_attrs(void *cls,
 225               const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
 226               const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 227 {
 228   char *value_str;
 229   char *id;
 230   const char *attr_type;
 231
 232   if (NULL == identity)
 233     {
 234       reclaim_op = NULL;
 235       cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 236       return;
 237     }
 238   if (NULL == attr)
 239     {
 240       ret = 1;
 241       return;
 242     }
 243   value_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string(attr->type,
 244                                                        attr->data,
 245                                                        attr->data_size);
 246   attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename(attr->type);
 247   id = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
 248   fprintf(stdout,
 249           "Name: %s; Value: %s (%s); Version %u; ID: %s\n",
 250           attr->name,
 251           value_str,
 252           attr_type,
 253           attr->version,
 254           id);
 255   GNUNET_free(id);
 256 }
 257
 258 static void
 259 ticket_iter_err(void *cls)
 260 {
 261   ticket_iterator = NULL;
 262   fprintf(stderr, "Failed to iterate over tickets\n");
 263   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 264 }
 265
 266 static void
 267 ticket_iter_fin(void *cls)
 268 {
 269   ticket_iterator = NULL;
 270   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 271 }
 272
 273 static void
 274 ticket_iter(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 275 {
 276   char *aud;
 277   char *ref;
 278   char *tkt;
 279
 280   aud =
 281     GNUNET_STRINGS_data_to_string_alloc(&ticket->audience,
 282                                         sizeof(struct
 283                                                GNUNET_CRYPTO_EcdsaPublicKey));
 284   ref = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
 285   tkt =
 286     GNUNET_STRINGS_data_to_string_alloc(ticket,
 287                                         sizeof(struct GNUNET_RECLAIM_Ticket));
 288   fprintf(stdout, "Ticket: %s | ID: %s | Audience: %s\n", tkt, ref, aud);
 289   GNUNET_free(aud);
 290   GNUNET_free(ref);
 291   GNUNET_free(tkt);
 292   GNUNET_RECLAIM_ticket_iteration_next(ticket_iterator);
 293 }
 294
 295 static void
 296 iter_error(void *cls)
 297 {
 298   attr_iterator = NULL;
 299   fprintf(stderr, "Failed to iterate over attributes\n");
 300   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 301 }
 302
 303 static void
 304 timeout_task(void *cls)
 305 {
 306   timeout = NULL;
 307   ret = 1;
 308   fprintf(stderr, "Timeout\n");
 309   if (NULL == cleanup_task)
 310     cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 311 }
 312
 313 static void
 314 process_rvk(void *cls, int success, const char *msg)
 315 {
 316   reclaim_op = NULL;
 317   if (GNUNET_OK != success)
 318     {
 319       fprintf(stderr, "Revocation failed.\n");
 320       ret = 1;
 321     }
 322   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 323 }
 324
 325
 326 static void
 327 process_delete(void *cls, int success, const char *msg)
 328 {
 329   reclaim_op = NULL;
 330   if (GNUNET_OK != success)
 331     {
 332       fprintf(stderr, "Deletion failed.\n");
 333       ret = 1;
 334     }
 335   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 336 }
 337
 338
 339 static void
 340 iter_finished(void *cls)
 341 {
 342   char *data;
 343   size_t data_size;
 344   int type;
 345
 346   attr_iterator = NULL;
 347   if (list)
 348     {
 349       cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 350       return;
 351     }
 352
 353   if (issue_attrs)
 354     {
 355       reclaim_op = GNUNET_RECLAIM_ticket_issue(reclaim_handle,
 356                                                pkey,
 357                                                &rp_key,
 358                                                attr_list,
 359                                                &ticket_issue_cb,
 360                                                NULL);
 361       return;
 362     }
 363   if (consume_ticket)
 364     {
 365       reclaim_op = GNUNET_RECLAIM_ticket_consume(reclaim_handle,
 366                                                  pkey,
 367                                                  &ticket,
 368                                                  &process_attrs,
 369                                                  NULL);
 370       timeout = GNUNET_SCHEDULER_add_delayed(
 371         GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
 372         &timeout_task,
 373         NULL);
 374       return;
 375     }
 376   if (revoke_ticket)
 377     {
 378       reclaim_op = GNUNET_RECLAIM_ticket_revoke(reclaim_handle,
 379                                                 pkey,
 380                                                 &ticket,
 381                                                 &process_rvk,
 382                                                 NULL);
 383       return;
 384     }
 385   if (attr_delete)
 386     {
 387       if (NULL == attr_to_delete)
 388         {
 389           fprintf(stdout, "No such attribute ``%s''\n", attr_delete);
 390           return;
 391         }
 392       reclaim_op = GNUNET_RECLAIM_attribute_delete(reclaim_handle,
 393                                                    pkey,
 394                                                    attr_to_delete,
 395                                                    &process_delete,
 396                                                    NULL);
 397       return;
 398     }
 399   if (attr_name)
 400     {
 401       if (NULL == type_str)
 402         type = GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING;
 403       else
 404         type = GNUNET_RECLAIM_ATTRIBUTE_typename_to_number(type_str);
 405
 406       GNUNET_assert(GNUNET_SYSERR !=
 407                     GNUNET_RECLAIM_ATTRIBUTE_string_to_value(type,
 408                                                              attr_value,
 409                                                              (void **)&data,
 410                                                              &data_size));
 411       if (NULL != claim)
 412         {
 413           claim->type = type;
 414           claim->data = data;
 415           claim->data_size = data_size;
 416         }
 417       else
 418         {
 419           claim =
 420             GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr_name, type, data, data_size);
 421         }
 422       reclaim_op = GNUNET_RECLAIM_attribute_store(reclaim_handle,
 423                                                   pkey,
 424                                                   claim,
 425                                                   &exp_interval,
 426                                                   &store_attr_cont,
 427                                                   NULL);
 428       GNUNET_free(data);
 429       GNUNET_free(claim);
 430       return;
 431     }
 432   cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 433 }
 434
 435 static void
 436 iter_cb(void *cls,
 437         const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
 438         const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 439 {
 440   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
 441   char *attrs_tmp;
 442   char *attr_str;
 443   char *label;
 444   char *id;
 445   const char *attr_type;
 446
 447   if ((NULL != attr_name) && (NULL != claim))
 448     {
 449       if (0 == strcasecmp(attr_name, attr->name))
 450         {
 451           claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr->name,
 452                                                      attr->type,
 453                                                      attr->data,
 454                                                      attr->data_size);
 455         }
 456     }
 457   else if (issue_attrs)
 458     {
 459       attrs_tmp = GNUNET_strdup(issue_attrs);
 460       attr_str = strtok(attrs_tmp, ",");
 461       while (NULL != attr_str)
 462         {
 463           if (0 != strcasecmp(attr_str, attr->name))
 464             {
 465               attr_str = strtok(NULL, ",");
 466               continue;
 467             }
 468           le = GNUNET_new(struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry);
 469           le->claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr->name,
 470                                                          attr->type,
 471                                                          attr->data,
 472                                                          attr->data_size);
 473           le->claim->version = attr->version;
 474           le->claim->id = attr->id;
 475           GNUNET_CONTAINER_DLL_insert(attr_list->list_head,
 476                                       attr_list->list_tail,
 477                                       le);
 478           break;
 479         }
 480       GNUNET_free(attrs_tmp);
 481     }
 482   else if (attr_delete && (NULL == attr_to_delete))
 483     {
 484       label = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
 485       if (0 == strcasecmp(attr_delete, label))
 486         {
 487           attr_to_delete = GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr->name,
 488                                                               attr->type,
 489                                                               attr->data,
 490                                                               attr->data_size);
 491           attr_to_delete->id = attr->id;
 492         }
 493       GNUNET_free(label);
 494     }
 495   else if (list)
 496     {
 497       attr_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string(attr->type,
 498                                                           attr->data,
 499                                                           attr->data_size);
 500       attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename(attr->type);
 501       id = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
 502       fprintf(stdout,
 503               "Name: %s; Value: %s (%s); Version %u; ID: %s\n",
 504               attr->name,
 505               attr_str,
 506               attr_type,
 507               attr->version,
 508               id);
 509       GNUNET_free(id);
 510     }
 511   GNUNET_RECLAIM_get_attributes_next(attr_iterator);
 512 }
 513
 514 static void
 515 start_process()
 516 {
 517   if (NULL == pkey)
 518     {
 519       fprintf(stderr, "Ego %s not found\n", ego_name);
 520       cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 521       return;
 522     }
 523
 524   if (list_tickets)
 525     {
 526       ticket_iterator = GNUNET_RECLAIM_ticket_iteration_start(reclaim_handle,
 527                                                               pkey,
 528                                                               &ticket_iter_err,
 529                                                               NULL,
 530                                                               &ticket_iter,
 531                                                               NULL,
 532                                                               &ticket_iter_fin,
 533                                                               NULL);
 534       return;
 535     }
 536
 537   if ((NULL != rp) &&
 538       GNUNET_OK !=
 539       GNUNET_CRYPTO_ecdsa_public_key_from_string(rp, strlen(rp), &rp_key))
 540     {
 541       fprintf(stderr, "%s is not a public key!\n", rp);
 542       cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
 543       return;
 544     }
 545   if (NULL != consume_ticket)
 546     GNUNET_STRINGS_string_to_data(consume_ticket,
 547                                   strlen(consume_ticket),
 548                                   &ticket,
 549                                   sizeof(struct GNUNET_RECLAIM_Ticket));
 550   if (NULL != revoke_ticket)
 551     GNUNET_STRINGS_string_to_data(revoke_ticket,
 552                                   strlen(revoke_ticket),
 553                                   &ticket,
 554                                   sizeof(struct GNUNET_RECLAIM_Ticket));
 555
 556   attr_list = GNUNET_new(struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList);
 557   claim = NULL;
 558   attr_iterator = GNUNET_RECLAIM_get_attributes_start(reclaim_handle,
 559                                                       pkey,
 560                                                       &iter_error,
 561                                                       NULL,
 562                                                       &iter_cb,
 563                                                       NULL,
 564                                                       &iter_finished,
 565                                                       NULL);
 566 }
 567
 568 static int init = GNUNET_YES;
 569
 570 static void
 571 ego_cb(void *cls,
 572        struct GNUNET_IDENTITY_Ego *ego,
 573        void **ctx,
 574        const char *name)
 575 {
 576   if (NULL == name)
 577     {
 578       if (GNUNET_YES == init)
 579         {
 580           init = GNUNET_NO;
 581           start_process();
 582         }
 583       return;
 584     }
 585   if (0 != strcmp(name, ego_name))
 586     return;
 587   pkey = GNUNET_IDENTITY_ego_get_private_key(ego);
 588 }
 589
 590
 591 static void
 592 run(void *cls,
 593     char *const *args,
 594     const char *cfgfile,
 595     const struct GNUNET_CONFIGURATION_Handle *c)
 596 {
 597   ret = 0;
 598   if (NULL == ego_name)
 599     {
 600       ret = 1;
 601       fprintf(stderr, _("Ego is required\n"));
 602       return;
 603     }
 604
 605   if ((NULL == attr_value) && (NULL != attr_name))
 606     {
 607       ret = 1;
 608       fprintf(stderr, _("Attribute value missing!\n"));
 609       return;
 610     }
 611
 612   if ((NULL == rp) && (NULL != issue_attrs))
 613     {
 614       ret = 1;
 615       fprintf(stderr, _("Requesting party key is required!\n"));
 616       return;
 617     }
 618
 619   reclaim_handle = GNUNET_RECLAIM_connect(c);
 620   // Get Ego
 621   identity_handle = GNUNET_IDENTITY_connect(c, &ego_cb, NULL);
 622 }
 623
 624
 625 int
 626 main(int argc, char *const argv[])
 627 {
 628   exp_interval = GNUNET_TIME_UNIT_HOURS;
 629   struct GNUNET_GETOPT_CommandLineOption options[] = {
 630     GNUNET_GETOPT_option_string('a',
 631                                 "add",
 632                                 "NAME",
 633                                 gettext_noop("Add an attribute NAME"),
 634                                 &attr_name),
 635     GNUNET_GETOPT_option_string('d',
 636                                 "delete",
 637                                 "ID",
 638                                 gettext_noop("Delete the attribute with ID"),
 639                                 &attr_delete),
 640     GNUNET_GETOPT_option_string('V',
 641                                 "value",
 642                                 "VALUE",
 643                                 gettext_noop("The attribute VALUE"),
 644                                 &attr_value),
 645     GNUNET_GETOPT_option_string('e',
 646                                 "ego",
 647                                 "EGO",
 648                                 gettext_noop("The EGO to use"),
 649                                 &ego_name),
 650     GNUNET_GETOPT_option_string('r',
 651                                 "rp",
 652                                 "RP",
 653                                 gettext_noop(
 654                                   "Specify the relying party for issue"),
 655                                 &rp),
 656     GNUNET_GETOPT_option_flag('D',
 657                               "dump",
 658                               gettext_noop("List attributes for EGO"),
 659                               &list),
 660     GNUNET_GETOPT_option_string(
 661       'i',
 662       "issue",
 663       "A1,A2,...",
 664       gettext_noop(
 665         "Issue a ticket for a set of attributes separated by comma"),
 666       &issue_attrs),
 667     GNUNET_GETOPT_option_string('C',
 668                                 "consume",
 669                                 "TICKET",
 670                                 gettext_noop("Consume a ticket"),
 671                                 &consume_ticket),
 672     GNUNET_GETOPT_option_string('R',
 673                                 "revoke",
 674                                 "TICKET",
 675                                 gettext_noop("Revoke a ticket"),
 676                                 &revoke_ticket),
 677     GNUNET_GETOPT_option_string('t',
 678                                 "type",
 679                                 "TYPE",
 680                                 gettext_noop("Type of attribute"),
 681                                 &type_str),
 682     GNUNET_GETOPT_option_flag('T',
 683                               "tickets",
 684                               gettext_noop("List tickets of ego"),
 685                               &list_tickets),
 686     GNUNET_GETOPT_option_relative_time('E',
 687                                        "expiration",
 688                                        "INTERVAL",
 689                                        gettext_noop(
 690                                          "Expiration interval of the attribute"),
 691                                        &exp_interval),
 692
 693     GNUNET_GETOPT_OPTION_END
 694   };
 695   if (GNUNET_OK != GNUNET_PROGRAM_run(argc,
 696                                       argv,
 697                                       "gnunet-reclaim",
 698                                       _("re:claimID command line tool"),
 699                                       options,
 700                                       &run,
 701                                       NULL))
 702     return 1;
 703   else
 704     return ret;
 705 }