src/identity-provider/identity_token.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2010-2015 GNUnet e.V.
   4
   5       GNUnet is free software; you can redistribute it and/or modify
   6       it under the terms of the GNU General Public License as published
   7       by the Free Software Foundation; either version 3, or (at your
   8       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       General Public License for more details.
  14
  15       You should have received a copy of the GNU General Public License
  16       along with GNUnet; see the file COPYING.  If not, write to the
  17       Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18       Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * @file identity-token/identity_token.c
  23  * @brief helper library to manage identity tokens
  24  * @author Martin Schanzenbach
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_signatures.h"
  29 #include "identity_token.h"
  30 #include <jansson.h>
  31 #include <inttypes.h>
  32
  33 #define JWT_ALG "alg"
  34
  35 #define JWT_ALG_VALUE "ED512"
  36
  37 #define JWT_TYP "typ"
  38
  39 #define JWT_TYP_VALUE "jwt"
  40
  41 /**
  42  * Crypto helper functions
  43  */
  44
  45 static int
  46 create_sym_key_from_ecdh(const struct GNUNET_HashCode *new_key_hash,
  47                          struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
  48                          struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
  49 {
  50   struct GNUNET_CRYPTO_HashAsciiEncoded new_key_hash_str;
  51
  52   GNUNET_CRYPTO_hash_to_enc (new_key_hash,
  53                              &new_key_hash_str);
  54   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating symmetric rsa key from %s\n", (char*)&new_key_hash_str);
  55   static const char ctx_key[] = "gnuid-aes-ctx-key";
  56   GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
  57                      new_key_hash, sizeof (struct GNUNET_HashCode),
  58                      ctx_key, strlen (ctx_key),
  59                      NULL, 0);
  60   static const char ctx_iv[] = "gnuid-aes-ctx-iv";
  61   GNUNET_CRYPTO_kdf (iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector),
  62                      new_key_hash, sizeof (struct GNUNET_HashCode),
  63                      ctx_iv, strlen (ctx_iv),
  64                      NULL, 0);
  65   return GNUNET_OK;
  66 }
  67
  68
  69
  70 /**
  71  * Decrypts data part from a token code
  72  */
  73 static int
  74 decrypt_str_ecdhe (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
  75                    const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_key,
  76                    const char *cyphertext,
  77                    size_t cyphertext_len,
  78                    char **result_str)
  79 {
  80   struct GNUNET_HashCode new_key_hash;
  81   struct GNUNET_CRYPTO_SymmetricSessionKey enc_key;
  82   struct GNUNET_CRYPTO_SymmetricInitializationVector enc_iv;
  83
  84   char *str_buf = GNUNET_malloc (cyphertext_len);
  85   size_t str_size;
  86
  87   //Calculate symmetric key from ecdh parameters
  88   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdsa_ecdh (priv_key,
  89                                                         ecdh_key,
  90                                                         &new_key_hash));
  91
  92   create_sym_key_from_ecdh (&new_key_hash,
  93                             &enc_key,
  94                             &enc_iv);
  95
  96   str_size = GNUNET_CRYPTO_symmetric_decrypt (cyphertext,
  97                                               cyphertext_len,
  98                                               &enc_key,
  99                                               &enc_iv,
 100                                               str_buf);
 101   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 102               "Decrypted bytes: %zd Expected bytes: %zd\n",
 103               str_size,
 104               cyphertext_len);
 105   if (-1 == str_size)
 106   {
 107     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ECDH invalid\n");
 108     GNUNET_free (str_buf);
 109     return GNUNET_SYSERR;
 110   }
 111   *result_str = GNUNET_malloc (str_size+1);
 112   memcpy (*result_str, str_buf, str_size);
 113   (*result_str)[str_size] = '\0';
 114   GNUNET_free (str_buf);
 115   return GNUNET_OK;
 116
 117 }
 118
 119 /**
 120  * Decrypt string using pubkey and ECDHE
 121 */
 122 static int
 123 decrypt_str_ecdhe2 (const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_privkey,
 124                     const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
 125                     const char *ciphertext,
 126                     size_t ciphertext_len,
 127                     char **plaintext)
 128 {
 129   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
 130   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 131   struct GNUNET_HashCode new_key_hash;
 132
 133   //This is true see documentation for GNUNET_CRYPTO_symmetric_encrypt
 134   *plaintext = GNUNET_malloc (ciphertext_len);
 135
 136   // Derived key K = H(eB)
 137   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdh_ecdsa (ecdh_privkey,
 138                                                         aud_key,
 139                                                         &new_key_hash));
 140   create_sym_key_from_ecdh(&new_key_hash, &skey, &iv);
 141   GNUNET_CRYPTO_symmetric_decrypt (ciphertext,
 142                                    ciphertext_len,
 143                                    &skey, &iv,
 144                                    *plaintext);
 145   return GNUNET_OK;
 146 }
 147
 148
 149 /**
 150  * Encrypt string using pubkey and ECDHE
 151  * Returns ECDHE pubkey to be used for decryption
 152  */
 153 static int
 154 encrypt_str_ecdhe (const char *plaintext,
 155                    const struct GNUNET_CRYPTO_EcdsaPublicKey *pub_key,
 156                    char **cyphertext,
 157                    struct GNUNET_CRYPTO_EcdhePrivateKey **ecdh_privkey,
 158                    struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pubkey)
 159 {
 160   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
 161   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 162   struct GNUNET_HashCode new_key_hash;
 163   ssize_t enc_size;
 164
 165   // ECDH keypair E = eG
 166   *ecdh_privkey = GNUNET_CRYPTO_ecdhe_key_create();
 167   GNUNET_CRYPTO_ecdhe_key_get_public (*ecdh_privkey,
 168                                       ecdh_pubkey);
 169
 170   //This is true see documentation for GNUNET_CRYPTO_symmetric_encrypt
 171   *cyphertext = GNUNET_malloc (strlen (plaintext));
 172
 173   // Derived key K = H(eB)
 174   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdh_ecdsa (*ecdh_privkey,
 175                                                         pub_key,
 176                                                         &new_key_hash));
 177   create_sym_key_from_ecdh(&new_key_hash, &skey, &iv);
 178   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting string %s\n (len=%zd)",
 179               plaintext,
 180               strlen (plaintext));
 181   enc_size = GNUNET_CRYPTO_symmetric_encrypt (plaintext,
 182                                               strlen (plaintext),
 183                                               &skey, &iv,
 184                                               *cyphertext);
 185   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypted (len=%zd)", enc_size);
 186   return GNUNET_OK;
 187 }
 188
 189
 190 /**
 191  * Identity Token API
 192  */
 193
 194
 195 /**
 196  * Create an Identity Token
 197  *
 198  * @param type the JSON API resource type
 199  * @param id the JSON API resource id
 200  * @return a new JSON API resource or NULL on error.
 201  */
 202 struct IdentityToken*
 203 token_create (const struct GNUNET_CRYPTO_EcdsaPublicKey* iss,
 204                                        const struct GNUNET_CRYPTO_EcdsaPublicKey* aud)
 205 {
 206   struct IdentityToken *token;
 207   char* audience;
 208   char* issuer;
 209
 210   issuer = GNUNET_STRINGS_data_to_string_alloc (iss,
 211                                                 sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
 212   audience = GNUNET_STRINGS_data_to_string_alloc (aud,
 213                                                   sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
 214
 215   token = GNUNET_malloc (sizeof (struct IdentityToken));
 216   token_add_attr (token, "iss", issuer);
 217   token_add_attr (token, "aud", audience);
 218   token_add_attr (token, "sub", issuer);
 219   token->aud_key = *aud;
 220   GNUNET_free (issuer);
 221   GNUNET_free (audience);
 222   return token;
 223 }
 224
 225 void
 226 token_destroy (struct IdentityToken *token)
 227 {
 228   struct TokenAttr *attr;
 229   struct TokenAttr *tmp_attr;
 230   struct TokenAttrValue *val;
 231   struct TokenAttrValue *tmp_val;
 232
 233   for (attr = token->attr_head; NULL != attr;)
 234   {
 235     tmp_attr = attr->next;
 236     GNUNET_CONTAINER_DLL_remove (token->attr_head,
 237                                  token->attr_tail,
 238                                  attr);
 239     for (val = attr->val_head; NULL != val;)
 240     {
 241       tmp_val = val->next;
 242       GNUNET_CONTAINER_DLL_remove (attr->val_head,
 243                                    attr->val_tail,
 244                                    val);
 245       if (NULL != val->value)
 246         GNUNET_free (val->value);
 247       GNUNET_free (val);
 248       val = tmp_val;
 249     }
 250     GNUNET_free (attr->name);
 251     GNUNET_free (attr);
 252     attr = tmp_attr;
 253   }
 254
 255
 256   GNUNET_free (token);
 257 }
 258
 259 void
 260 token_add_attr (struct IdentityToken *token,
 261                 const char* key,
 262                 const char* value)
 263 {
 264   struct TokenAttr *attr;
 265   struct TokenAttrValue *new_val;
 266   GNUNET_assert (NULL != token);
 267
 268   new_val = GNUNET_malloc (sizeof (struct TokenAttrValue));
 269   new_val->value = GNUNET_strdup (value);
 270   for (attr = token->attr_head; NULL != attr; attr = attr->next)
 271   {
 272     if (0 == strcmp (key, attr->name))
 273       break;
 274   }
 275
 276   if (NULL == attr)
 277   {
 278     attr = GNUNET_malloc (sizeof (struct TokenAttr));
 279     attr->name = GNUNET_strdup (key);
 280     GNUNET_CONTAINER_DLL_insert (token->attr_head,
 281                                  token->attr_tail,
 282                                  attr);
 283   }
 284
 285   GNUNET_CONTAINER_DLL_insert (attr->val_head,
 286                                attr->val_tail,
 287                                new_val);
 288 }
 289
 290 void
 291 token_add_attr_int (struct IdentityToken *token,
 292                     const char* key,
 293                     uint64_t value)
 294 {
 295   struct TokenAttr *attr;
 296   struct TokenAttrValue *new_val;
 297   GNUNET_assert (NULL != token);
 298
 299   new_val = GNUNET_malloc (sizeof (struct TokenAttrValue));
 300   new_val->int_value = value;
 301   for (attr = token->attr_head; NULL != attr; attr = attr->next)
 302   {
 303     if (0 == strcmp (key, attr->name))
 304       break;
 305   }
 306
 307   if (NULL == attr)
 308   {
 309     attr = GNUNET_malloc (sizeof (struct TokenAttr));
 310     attr->name = GNUNET_strdup (key);
 311     GNUNET_CONTAINER_DLL_insert (token->attr_head,
 312                                  token->attr_tail,
 313                                  attr);
 314   }
 315
 316   GNUNET_CONTAINER_DLL_insert (attr->val_head,
 317                                attr->val_tail,
 318                                new_val);
 319 }
 320
 321 static void
 322 parse_json_payload(const char* payload_base64,
 323                    struct IdentityToken *token)
 324 {
 325   const char *key;
 326   const json_t *value;
 327   const json_t *arr_value;
 328   char *payload;
 329   int idx;
 330   json_t *payload_json;
 331   json_error_t err_json;
 332
 333   GNUNET_STRINGS_base64_decode (payload_base64,
 334                                 strlen (payload_base64),
 335                                 &payload);
 336   //TODO signature and aud key
 337   payload_json = json_loads (payload, JSON_DECODE_ANY, &err_json);
 338
 339   json_object_foreach (payload_json, key, value)
 340   {
 341     if (json_is_array (value))
 342     {
 343       json_array_foreach (value, idx, arr_value)
 344       {
 345         if (json_is_integer (arr_value))
 346           token_add_attr_int (token, key,
 347                               json_integer_value (arr_value));
 348         else
 349           token_add_attr (token,
 350                           key,
 351                           json_string_value (arr_value));
 352       }
 353     } else {
 354       if (json_is_integer (value))
 355         token_add_attr_int (token, key,
 356                             json_integer_value (value));
 357       else
 358         token_add_attr (token, key, json_string_value (value));
 359     }
 360   }
 361
 362   json_decref (payload_json);
 363   GNUNET_free (payload);
 364 }
 365
 366 int
 367 token_parse2 (const char* raw_data,
 368               const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_key,
 369               const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
 370               struct IdentityToken **result)
 371 {
 372   char *enc_token_str;
 373   char *tmp_buf;
 374   char *token_str;
 375   char *enc_token;
 376   char *payload_base64;
 377   size_t enc_token_len;
 378
 379   GNUNET_asprintf (&tmp_buf, "%s", raw_data);
 380   strtok (tmp_buf, ",");
 381   enc_token_str = strtok (NULL, ",");
 382
 383   enc_token_len = GNUNET_STRINGS_base64_decode (enc_token_str,
 384                                                 strlen (enc_token_str),
 385                                                 &enc_token);
 386   if (GNUNET_OK != decrypt_str_ecdhe2 (priv_key,
 387                                        aud_key,
 388                                        enc_token,
 389                                        enc_token_len,
 390                                        &token_str))
 391   {
 392     GNUNET_free (tmp_buf);
 393     GNUNET_free (enc_token);
 394     return GNUNET_SYSERR;
 395   }
 396
 397   GNUNET_assert (NULL != strtok (token_str, "."));
 398   payload_base64 = strtok (NULL, ".");
 399
 400   *result = GNUNET_malloc (sizeof (struct IdentityToken));
 401   parse_json_payload (payload_base64, *result);
 402
 403   (*result)->aud_key =  *aud_key;
 404   GNUNET_free (enc_token);
 405   GNUNET_free (token_str);
 406   GNUNET_free (tmp_buf);
 407   return GNUNET_OK;
 408 }
 409
 410 int
 411 token_parse (const char* raw_data,
 412              const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 413              struct IdentityToken **result)
 414 {
 415   char *ecdh_pubkey_str;
 416   char *enc_token_str;
 417   char *tmp_buf;
 418   char *token_str;
 419   char *enc_token;
 420   char *payload_base64;
 421   size_t enc_token_len;
 422   struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pubkey;
 423
 424   GNUNET_asprintf (&tmp_buf, "%s", raw_data);
 425   ecdh_pubkey_str = strtok (tmp_buf, ",");
 426   enc_token_str = strtok (NULL, ",");
 427
 428   GNUNET_STRINGS_string_to_data (ecdh_pubkey_str,
 429                                  strlen (ecdh_pubkey_str),
 430                                  &ecdh_pubkey,
 431                                  sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
 432   enc_token_len = GNUNET_STRINGS_base64_decode (enc_token_str,
 433                                                 strlen (enc_token_str),
 434                                                 &enc_token);
 435   if (GNUNET_OK != decrypt_str_ecdhe (priv_key,
 436                                       &ecdh_pubkey,
 437                                       enc_token,
 438                                       enc_token_len,
 439                                       &token_str))
 440   {
 441     GNUNET_free (tmp_buf);
 442     GNUNET_free (enc_token);
 443     return GNUNET_SYSERR;
 444   }
 445
 446   GNUNET_assert (NULL != strtok (token_str, "."));
 447   payload_base64 = strtok (NULL, ".");
 448
 449   *result = GNUNET_malloc (sizeof (struct IdentityToken));
 450   parse_json_payload (payload_base64, *result);
 451
 452   GNUNET_free (enc_token);
 453   GNUNET_free (token_str);
 454   GNUNET_free (tmp_buf);
 455   return GNUNET_OK;
 456 }
 457
 458 static char*
 459 create_json_payload (const struct IdentityToken *token)
 460 {
 461   struct TokenAttr *attr;
 462   struct TokenAttrValue *val;
 463   json_t *root;
 464   char *json_str;
 465
 466   root = json_object();
 467   for (attr = token->attr_head; NULL != attr; attr = attr->next)
 468   {
 469     for (val = attr->val_head; NULL != val; val = val->next)
 470     {
 471       if (NULL != val->value)
 472       {
 473         json_object_set_new (root,
 474                              attr->name,
 475                              json_string (val->value));
 476       } else {
 477         json_object_set_new (root,
 478                              attr->name,
 479                              json_integer (val->int_value));
 480       }
 481     }
 482   }
 483   json_str = json_dumps (root, JSON_INDENT(1));
 484   json_decref (root);
 485   return json_str;
 486 }
 487
 488 static char*
 489 create_json_header(void)
 490 {
 491   json_t *root;
 492   char *json_str;
 493
 494   root = json_object ();
 495   json_object_set_new (root, JWT_ALG, json_string (JWT_ALG_VALUE));
 496   json_object_set_new (root, JWT_TYP, json_string (JWT_TYP_VALUE));
 497
 498   json_str = json_dumps (root, JSON_INDENT(1));
 499   json_decref (root);
 500   return json_str;
 501 }
 502
 503 int
 504 token_to_string (const struct IdentityToken *token,
 505                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 506                  char **result)
 507 {
 508   char *payload_str;
 509   char *header_str;
 510   char *payload_base64;
 511   char *header_base64;
 512   char *padding;
 513   char *signature_target;
 514   char *signature_str;
 515   struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
 516   header_str = create_json_header();
 517   GNUNET_STRINGS_base64_encode (header_str,
 518                                 strlen (header_str),
 519                                 &header_base64);
 520   //Remove GNUNET padding of base64
 521   padding = strtok(header_base64, "=");
 522   while (NULL != padding)
 523     padding = strtok(NULL, "=");
 524
 525   payload_str = create_json_payload (token);
 526   GNUNET_STRINGS_base64_encode (payload_str,
 527                                 strlen (payload_str),
 528                                 &payload_base64);
 529
 530   //Remove GNUNET padding of base64
 531   padding = strtok(payload_base64, "=");
 532   while (NULL != padding)
 533     padding = strtok(NULL, "=");
 534
 535   GNUNET_asprintf (&signature_target, "%s,%s", header_base64, payload_base64);
 536   purpose =
 537     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 538                    strlen (signature_target));
 539   purpose->size =
 540     htonl (strlen (signature_target) + sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
 541   purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN);
 542   memcpy (&purpose[1], signature_target, strlen (signature_target));
 543   if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_sign (priv_key,
 544                                              purpose,
 545                                              (struct GNUNET_CRYPTO_EcdsaSignature *)&token->signature))
 546   {
 547     GNUNET_free (signature_target);
 548     GNUNET_free (payload_str);
 549     GNUNET_free (payload_base64);
 550     GNUNET_free (purpose);
 551     return GNUNET_SYSERR;
 552   }
 553
 554   GNUNET_STRINGS_base64_encode ((const char*)&token->signature,
 555                                 sizeof (struct GNUNET_CRYPTO_EcdsaSignature),
 556                                 &signature_str);
 557   GNUNET_asprintf (result, "%s.%s.%s",
 558                    header_base64, payload_base64, signature_str);
 559   GNUNET_free (signature_target);
 560   GNUNET_free (payload_str);
 561   GNUNET_free (header_str);
 562   GNUNET_free (signature_str);
 563   GNUNET_free (payload_base64);
 564   GNUNET_free (header_base64);
 565   GNUNET_free (purpose);
 566   return GNUNET_OK;
 567 }
 568
 569 int
 570 token_serialize (const struct IdentityToken *token,
 571                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 572                  struct GNUNET_CRYPTO_EcdhePrivateKey **ecdh_privkey,
 573                  char **result)
 574 {
 575   char *token_str;
 576   char *enc_token;
 577   char *dh_key_str;
 578   char *enc_token_base64;
 579   struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pubkey;
 580
 581   GNUNET_assert (GNUNET_OK == token_to_string (token,
 582                                                priv_key,
 583                                                &token_str));
 584
 585   GNUNET_assert (GNUNET_OK == encrypt_str_ecdhe (token_str,
 586                                                  &token->aud_key,
 587                                                  &enc_token,
 588                                                  ecdh_privkey,
 589                                                  &ecdh_pubkey));
 590   GNUNET_STRINGS_base64_encode (enc_token,
 591                                 strlen (token_str),
 592                                 &enc_token_base64);
 593   dh_key_str = GNUNET_STRINGS_data_to_string_alloc (&ecdh_pubkey,
 594                                                     sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
 595   GNUNET_asprintf (result, "%s,%s", dh_key_str, enc_token_base64);
 596   GNUNET_free (dh_key_str);
 597   GNUNET_free (enc_token_base64);
 598   GNUNET_free (enc_token);
 599   GNUNET_free (token_str);
 600   return GNUNET_OK;
 601 }
 602
 603 struct TokenTicketPayload*
 604 ticket_payload_create (uint64_t nonce,
 605                        const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
 606                        const char* lbl_str)
 607 {
 608   struct TokenTicketPayload* payload;
 609
 610   payload = GNUNET_malloc (sizeof (struct TokenTicketPayload));
 611   payload->nonce = nonce;
 612   payload->identity_key = *identity_pkey;
 613   GNUNET_asprintf (&payload->label, lbl_str, strlen (lbl_str));
 614   return payload;
 615 }
 616
 617 void
 618 ticket_payload_destroy (struct TokenTicketPayload* payload)
 619 {
 620   if (NULL != payload->label)
 621     GNUNET_free (payload->label);
 622   GNUNET_free (payload);
 623 }
 624
 625 void
 626 ticket_payload_serialize (struct TokenTicketPayload *payload,
 627                           char **result)
 628 {
 629   char* identity_key_str;
 630
 631   identity_key_str = GNUNET_STRINGS_data_to_string_alloc (&payload->identity_key,
 632                                                           sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
 633
 634   GNUNET_asprintf (result,
 635                    "{\"nonce\": \"%"SCNu64"\",\"identity\": \"%s\",\"label\": \"%s\"}",
 636                    payload->nonce, identity_key_str, payload->label);
 637   GNUNET_free (identity_key_str);
 638
 639 }
 640
 641
 642 /**
 643  * Create the token code
 644  * The data is encrypted with a share ECDH derived secret using B (aud_key)
 645  * and e (ecdh_privkey)
 646  * The ticket also contains E (ecdh_pubkey) and a signature over the
 647  * data and E
 648  */
 649 struct TokenTicket*
 650 ticket_create (uint64_t nonce,
 651                const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
 652                const char* lbl_str,
 653                const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key)
 654 {
 655   struct TokenTicket *ticket;
 656   struct TokenTicketPayload *code_payload;
 657
 658   ticket = GNUNET_malloc (sizeof (struct TokenTicket));
 659   code_payload = ticket_payload_create (nonce,
 660                                         identity_pkey,
 661                                         lbl_str);
 662   ticket->aud_key = *aud_key;
 663   ticket->payload = code_payload;
 664
 665
 666   return ticket;
 667 }
 668
 669 void
 670 ticket_destroy (struct TokenTicket *ticket)
 671 {
 672   ticket_payload_destroy (ticket->payload);
 673   GNUNET_free (ticket);
 674 }
 675
 676 int
 677 ticket_serialize (struct TokenTicket *ticket,
 678                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 679                   char **result)
 680 {
 681   char *code_payload_str;
 682   char *enc_ticket_payload;
 683   char *ticket_payload_str;
 684   char *ticket_sig_str;
 685   char *ticket_str;
 686   char *dh_key_str;
 687   char *write_ptr;
 688   struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe_privkey;
 689
 690   struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
 691
 692   ticket_payload_serialize (ticket->payload,
 693                             &code_payload_str);
 694
 695   GNUNET_assert (GNUNET_OK == encrypt_str_ecdhe (code_payload_str,
 696                                                  &ticket->aud_key,
 697                                                  &enc_ticket_payload,
 698                                                  &ecdhe_privkey,
 699                                                  &ticket->ecdh_pubkey));
 700
 701   GNUNET_free (ecdhe_privkey);
 702
 703   purpose =
 704     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 705                    sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + //E
 706                    strlen (code_payload_str)); // E_K (code_str)
 707   purpose->size =
 708     htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 709            sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
 710            strlen (code_payload_str));
 711   purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET);
 712   write_ptr = (char*) &purpose[1];
 713   memcpy (write_ptr,
 714           &ticket->ecdh_pubkey,
 715           sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
 716   write_ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
 717   memcpy (write_ptr, enc_ticket_payload, strlen (code_payload_str));
 718   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdsa_sign (priv_key,
 719                                                         purpose,
 720                                                         &ticket->signature));
 721   GNUNET_STRINGS_base64_encode (enc_ticket_payload,
 722                                 strlen (code_payload_str),
 723                                 &ticket_payload_str);
 724   ticket_sig_str = GNUNET_STRINGS_data_to_string_alloc (&ticket->signature,
 725                                                         sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
 726
 727   dh_key_str = GNUNET_STRINGS_data_to_string_alloc (&ticket->ecdh_pubkey,
 728                                                     sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
 729   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using ECDH pubkey %s to encrypt\n", dh_key_str);
 730   GNUNET_asprintf (&ticket_str, "{\"data\": \"%s\", \"ecdh\": \"%s\", \"signature\": \"%s\"}",
 731                    ticket_payload_str, dh_key_str, ticket_sig_str);
 732   GNUNET_STRINGS_base64_encode (ticket_str, strlen (ticket_str), result);
 733   GNUNET_free (dh_key_str);
 734   GNUNET_free (purpose);
 735   GNUNET_free (ticket_str);
 736   GNUNET_free (ticket_sig_str);
 737   GNUNET_free (code_payload_str);
 738   GNUNET_free (enc_ticket_payload);
 739   GNUNET_free (ticket_payload_str);
 740   return GNUNET_OK;
 741 }
 742
 743 int
 744 ticket_payload_parse(const char *raw_data,
 745                      ssize_t data_len,
 746                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 747                      const struct GNUNET_CRYPTO_EcdhePublicKey *ecdhe_pkey,
 748                      struct TokenTicketPayload **result)
 749 {
 750   const char* label_str;
 751   const char* nonce_str;
 752   const char* identity_key_str;
 753
 754   json_t *root;
 755   json_t *label_json;
 756   json_t *identity_json;
 757   json_t *nonce_json;
 758   json_error_t err_json;
 759   char* data_str;
 760   uint64_t nonce;
 761   struct GNUNET_CRYPTO_EcdsaPublicKey id_pkey;
 762
 763   if (GNUNET_OK != decrypt_str_ecdhe (priv_key,
 764                                       ecdhe_pkey,
 765                                       raw_data,
 766                                       data_len,
 767                                       &data_str))
 768   {
 769     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Data decryption failed\n");
 770     return GNUNET_SYSERR;
 771   }
 772
 773   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Data: %s\n", data_str);
 774   root = json_loads (data_str, JSON_DECODE_ANY, &err_json);
 775   if (!root)
 776   {
 777     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 778                 "Error parsing data: %s\n", err_json.text);
 779     GNUNET_free (data_str);
 780     return GNUNET_SYSERR;
 781   }
 782
 783   identity_json = json_object_get (root, "identity");
 784   if (!json_is_string (identity_json))
 785   {
 786     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 787                 "Error parsing data: %s\n", err_json.text);
 788     json_decref (root);
 789     GNUNET_free (data_str);
 790     return GNUNET_SYSERR;
 791   }
 792   identity_key_str = json_string_value (identity_json);
 793   GNUNET_STRINGS_string_to_data (identity_key_str,
 794                                  strlen (identity_key_str),
 795                                  &id_pkey,
 796                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
 797
 798
 799   label_json = json_object_get (root, "label");
 800   if (!json_is_string (label_json))
 801   {
 802     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 803                 "Error parsing data: %s\n", err_json.text);
 804     json_decref (root);
 805     GNUNET_free (data_str);
 806     return GNUNET_SYSERR;
 807   }
 808
 809   label_str = json_string_value (label_json);
 810   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found label: %s\n", label_str);
 811
 812   nonce_json = json_object_get (root, "nonce");
 813   if (!json_is_string (label_json))
 814   {
 815     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 816                 "Error parsing data: %s\n", err_json.text);
 817     json_decref (root);
 818     GNUNET_free (data_str);
 819     return GNUNET_SYSERR;
 820   }
 821
 822   nonce_str = json_string_value (nonce_json);
 823   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found nonce: %s\n", nonce_str);
 824
 825   GNUNET_assert (0 != sscanf (nonce_str, "%"SCNu64, &nonce));
 826
 827   *result = ticket_payload_create (nonce,
 828                                    (const struct GNUNET_CRYPTO_EcdsaPublicKey*)&id_pkey,
 829                                    label_str);
 830   GNUNET_free (data_str);
 831   json_decref (root);
 832   return GNUNET_OK;
 833
 834 }
 835
 836 int
 837 ticket_parse (const char *raw_data,
 838               const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 839               struct TokenTicket **result)
 840 {
 841   const char* enc_data_str;
 842   const char* ecdh_enc_str;
 843   const char* signature_enc_str;
 844
 845   json_t *root;
 846   json_t *signature_json;
 847   json_t *ecdh_json;
 848   json_t *enc_data_json;
 849   json_error_t err_json;
 850   char* enc_data;
 851   char* ticket_decoded;
 852   char* write_ptr;
 853   size_t enc_data_len;
 854   struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
 855   struct TokenTicket *ticket;
 856   struct TokenTicketPayload *ticket_payload;
 857
 858   ticket_decoded = NULL;
 859   GNUNET_STRINGS_base64_decode (raw_data, strlen (raw_data), &ticket_decoded);
 860   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ticket: %s\n", ticket_decoded);
 861   root = json_loads (ticket_decoded, JSON_DECODE_ANY, &err_json);
 862   if (!root)
 863   {
 864     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 865                 "%s\n", err_json.text);
 866     return GNUNET_SYSERR;
 867   }
 868
 869   signature_json = json_object_get (root, "signature");
 870   ecdh_json = json_object_get (root, "ecdh");
 871   enc_data_json = json_object_get (root, "data");
 872
 873   signature_enc_str = json_string_value (signature_json);
 874   ecdh_enc_str = json_string_value (ecdh_json);
 875   enc_data_str = json_string_value (enc_data_json);
 876
 877   ticket = GNUNET_malloc (sizeof (struct TokenTicket));
 878
 879   if (GNUNET_OK != GNUNET_STRINGS_string_to_data (ecdh_enc_str,
 880                                                   strlen (ecdh_enc_str),
 881                                                   &ticket->ecdh_pubkey,
 882                                                   sizeof  (struct GNUNET_CRYPTO_EcdhePublicKey)))
 883   {
 884     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ECDH PKEY %s invalid in data\n", ecdh_enc_str);
 885     json_decref (root);
 886     GNUNET_free (ticket);
 887     return GNUNET_SYSERR;
 888   }
 889   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using ECDH pubkey %s for data decryption\n", ecdh_enc_str);
 890   if (GNUNET_OK != GNUNET_STRINGS_string_to_data (signature_enc_str,
 891                                                   strlen (signature_enc_str),
 892                                                   &ticket->signature,
 893                                                   sizeof (struct GNUNET_CRYPTO_EcdsaSignature)))
 894   {
 895     json_decref (root);
 896     GNUNET_free (ticket_decoded);
 897     GNUNET_free (ticket);
 898     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ECDH signature invalid in data\n");
 899     return GNUNET_SYSERR;
 900   }
 901
 902   enc_data_len = GNUNET_STRINGS_base64_decode (enc_data_str,
 903                                                strlen (enc_data_str),
 904                                                &enc_data);
 905
 906
 907   if (GNUNET_OK != ticket_payload_parse (enc_data,
 908                                          enc_data_len,
 909                                          priv_key,
 910                                          (const struct GNUNET_CRYPTO_EcdhePublicKey*)&ticket->ecdh_pubkey,
 911                                          &ticket_payload))
 912   {
 913     json_decref (root);
 914     GNUNET_free (enc_data);
 915     GNUNET_free (ticket_decoded);
 916     GNUNET_free (ticket);
 917     return GNUNET_SYSERR;
 918   }
 919
 920   ticket->payload = ticket_payload;
 921   purpose =
 922     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 923                    sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + //E
 924                    enc_data_len); // E_K (code_str)
 925   purpose->size =
 926     htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 927            sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
 928            enc_data_len);
 929   purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET);
 930   write_ptr = (char*) &purpose[1];
 931   memcpy (write_ptr, &ticket->ecdh_pubkey, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
 932   write_ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
 933   memcpy (write_ptr, enc_data, enc_data_len);
 934
 935   if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET,
 936                                                purpose,
 937                                                &ticket->signature,
 938                                                &ticket_payload->identity_key))
 939   {
 940     ticket_destroy (ticket);
 941     GNUNET_free (ticket_decoded);
 942     json_decref (root);
 943     GNUNET_free (purpose);
 944     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 945                 "Error verifying signature for ticket\n");
 946     return GNUNET_SYSERR;
 947   }
 948   *result = ticket;
 949   GNUNET_free (purpose);
 950
 951   GNUNET_free (enc_data);
 952   GNUNET_free (ticket_decoded);
 953   json_decref (root);
 954   return GNUNET_OK;
 955
 956 }
 957
 958
 959
 960 /* end of identity_token.c */