exchange

Base system with REST service to issue digital coins, run by the payment service provider
Log | Files | Refs | Submodules | README | LICENSE

exchange_api_get-keys.c (17621B)


      1 /*
      2   This file is part of TALER
      3   Copyright (C) 2014-2026 Taler Systems SA
      4 
      5   TALER is free software; you can redistribute it and/or modify it under the
      6   terms of the GNU General Public License as published by the Free Software
      7   Foundation; either version 3, or (at your option) any later version.
      8 
      9   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
     10   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
     11   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
     12 
     13   You should have received a copy of the GNU General Public License along with
     14   TALER; see the file COPYING.  If not, see
     15   <http://www.gnu.org/licenses/>
     16 */
     17 /**
     18  * @file lib/exchange_api_get-keys.c
     19  * @brief Implementation of GET /keys
     20  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
     21  * @author Christian Grothoff
     22  */
     23 #include "platform.h"  /* UNNECESSARY? */
     24 #include <microhttpd.h>
     25 #include <gnunet/gnunet_curl_lib.h>
     26 #include "taler/taler_json_lib.h"
     27 #include "taler/taler_exchange_service.h"  /* UNNECESSARY? */
     28 #include "taler/taler_signatures.h"
     29 #include "exchange_api_handle.h"
     30 #include "exchange_api_curl_defaults.h"
     31 #include "taler/taler_curl_lib.h"
     32 
     33 /**
     34  * If the "Expire" cache control header is missing, for
     35  * how long do we assume the reply to be valid at least?
     36  */
     37 #define DEFAULT_EXPIRATION GNUNET_TIME_UNIT_HOURS
     38 
     39 /**
     40  * If the "Expire" cache control header is missing, for
     41  * how long do we assume the reply to be valid at least?
     42  */
     43 #define MINIMUM_EXPIRATION GNUNET_TIME_relative_multiply ( \
     44           GNUNET_TIME_UNIT_MINUTES, 2)
     45 
     46 /**
     47  * Define a max length for the HTTP "Expire:" header
     48  */
     49 #define MAX_DATE_LINE_LEN 32
     50 
     51 
     52 /**
     53  * Handle for a GET /keys request.
     54  */
     55 struct TALER_EXCHANGE_GetKeysHandle
     56 {
     57 
     58   /**
     59    * The exchange base URL (i.e. "https://exchange.demo.taler.net/")
     60    */
     61   char *exchange_url;
     62 
     63   /**
     64    * The url for the /keys request, set during _start.
     65    */
     66   char *url;
     67 
     68   /**
     69    * Previous /keys response, NULL for none.
     70    */
     71   struct TALER_EXCHANGE_Keys *prev_keys;
     72 
     73   /**
     74    * Entry for this request with the `struct GNUNET_CURL_Context`.
     75    */
     76   struct GNUNET_CURL_Job *job;
     77 
     78   /**
     79    * Expiration time according to "Expire:" header.
     80    * 0 if not provided by the server.
     81    */
     82   struct GNUNET_TIME_Timestamp expire;
     83 
     84   /**
     85    * Function to call with the exchange's certification data,
     86    * NULL if this has already been done.
     87    */
     88   TALER_EXCHANGE_GetKeysCallback cert_cb;
     89 
     90   /**
     91    * Closure to pass to @e cert_cb.
     92    */
     93   TALER_EXCHANGE_GET_KEYS_RESULT_CLOSURE *cert_cb_cls;
     94 
     95   /**
     96    * Reference to the execution context.
     97    */
     98   struct GNUNET_CURL_Context *ctx;
     99 
    100 };
    101 
    102 
    103 /**
    104  * Parse HTTP timestamp.
    105  *
    106  * @param dateline header to parse header
    107  * @param[out] at where to write the result
    108  * @return #GNUNET_OK on success
    109  */
    110 static enum GNUNET_GenericReturnValue
    111 parse_date_string (const char *dateline,
    112                    struct GNUNET_TIME_Timestamp *at)
    113 {
    114   static const char *MONTHS[] =
    115   { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    116     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL };
    117   int year;
    118   int mon;
    119   int day;
    120   int hour;
    121   int min;
    122   int sec;
    123   char month[4];
    124   struct tm tm;
    125   time_t t;
    126 
    127   /* We recognize the three formats in RFC2616, section 3.3.1.  Month
    128      names are always in English.  The formats are:
    129       Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
    130       Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
    131       Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
    132      Note that the first is preferred.
    133    */
    134 
    135   if (strlen (dateline) > MAX_DATE_LINE_LEN)
    136   {
    137     GNUNET_break_op (0);
    138     return GNUNET_SYSERR;
    139   }
    140   while (*dateline == ' ')
    141     ++dateline;
    142   while (*dateline && *dateline != ' ')
    143     ++dateline;
    144   while (*dateline == ' ')
    145     ++dateline;
    146   /* We just skipped over the day of the week. Now we have:*/
    147   if ( (sscanf (dateline,
    148                 "%d %3s %d %d:%d:%d",
    149                 &day, month, &year, &hour, &min, &sec) != 6) &&
    150        (sscanf (dateline,
    151                 "%d-%3s-%d %d:%d:%d",
    152                 &day, month, &year, &hour, &min, &sec) != 6) &&
    153        (sscanf (dateline,
    154                 "%3s %d %d:%d:%d %d",
    155                 month, &day, &hour, &min, &sec, &year) != 6) )
    156   {
    157     GNUNET_break (0);
    158     return GNUNET_SYSERR;
    159   }
    160   /* Two digit dates are defined to be relative to 1900; all other dates
    161    * are supposed to be represented as four digits. */
    162   if (year < 100)
    163     year += 1900;
    164 
    165   for (mon = 0; ; mon++)
    166   {
    167     if (! MONTHS[mon])
    168     {
    169       GNUNET_break_op (0);
    170       return GNUNET_SYSERR;
    171     }
    172     if (0 == strcasecmp (month,
    173                          MONTHS[mon]))
    174       break;
    175   }
    176 
    177   memset (&tm, 0, sizeof(tm));
    178   tm.tm_year = year - 1900;
    179   tm.tm_mon = mon;
    180   tm.tm_mday = day;
    181   tm.tm_hour = hour;
    182   tm.tm_min = min;
    183   tm.tm_sec = sec;
    184 
    185   t = mktime (&tm);
    186   if (((time_t) -1) == t)
    187   {
    188     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
    189                          "mktime");
    190     return GNUNET_SYSERR;
    191   }
    192   if (t < 0)
    193     t = 0; /* can happen due to timezone issues if date was 1.1.1970 */
    194   *at = GNUNET_TIME_timestamp_from_s (t);
    195   return GNUNET_OK;
    196 }
    197 
    198 
    199 /**
    200  * Function called for each header in the HTTP /keys response.
    201  * Finds the "Expire:" header and parses it, storing the result
    202  * in the "expire" field of the keys request.
    203  *
    204  * @param buffer header data received
    205  * @param size size of an item in @a buffer
    206  * @param nitems number of items in @a buffer
    207  * @param userdata the `struct TALER_EXCHANGE_GetKeysHandle`
    208  * @return `size * nitems` on success (everything else aborts)
    209  */
    210 static size_t
    211 header_cb (char *buffer,
    212            size_t size,
    213            size_t nitems,
    214            void *userdata)
    215 {
    216   struct TALER_EXCHANGE_GetKeysHandle *kr = userdata;
    217   size_t total = size * nitems;
    218   char *val;
    219 
    220   if (total < strlen (MHD_HTTP_HEADER_EXPIRES ": "))
    221     return total;
    222   if (0 != strncasecmp (MHD_HTTP_HEADER_EXPIRES ": ",
    223                         buffer,
    224                         strlen (MHD_HTTP_HEADER_EXPIRES ": ")))
    225     return total;
    226   val = GNUNET_strndup (&buffer[strlen (MHD_HTTP_HEADER_EXPIRES ": ")],
    227                         total - strlen (MHD_HTTP_HEADER_EXPIRES ": "));
    228   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
    229               "Found %s header `%s'\n",
    230               MHD_HTTP_HEADER_EXPIRES,
    231               val);
    232   if (GNUNET_OK !=
    233       parse_date_string (val,
    234                          &kr->expire))
    235   {
    236     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
    237                 "Failed to parse %s-header `%s'\n",
    238                 MHD_HTTP_HEADER_EXPIRES,
    239                 val);
    240     kr->expire = GNUNET_TIME_UNIT_ZERO_TS;
    241   }
    242   GNUNET_free (val);
    243   return total;
    244 }
    245 
    246 
    247 /**
    248  * Callback used when downloading the reply to a /keys request
    249  * is complete.
    250  *
    251  * @param cls the `struct TALER_EXCHANGE_GetKeysHandle`
    252  * @param response_code HTTP response code, 0 on error
    253  * @param resp_obj parsed JSON result, NULL on error
    254  */
    255 static void
    256 keys_completed_cb (void *cls,
    257                    long response_code,
    258                    const void *resp_obj)
    259 {
    260   struct TALER_EXCHANGE_GetKeysHandle *gkh = cls;
    261   const json_t *j = resp_obj;
    262   struct TALER_EXCHANGE_Keys *kd = NULL;
    263   struct TALER_EXCHANGE_KeysResponse kresp = {
    264     .hr.reply = j,
    265     .hr.http_status = (unsigned int) response_code,
    266     .details.ok.compat = TALER_EXCHANGE_VC_PROTOCOL_ERROR,
    267   };
    268 
    269   gkh->job = NULL;
    270   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
    271               "Received keys from URL `%s' with status %ld and expiration %s.\n",
    272               gkh->url,
    273               response_code,
    274               GNUNET_TIME_timestamp2s (gkh->expire));
    275   if (GNUNET_TIME_absolute_is_past (gkh->expire.abs_time))
    276   {
    277     if (MHD_HTTP_OK == response_code)
    278       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
    279                   "Exchange failed to give expiration time, assuming in %s\n",
    280                   GNUNET_TIME_relative2s (DEFAULT_EXPIRATION,
    281                                           true));
    282     gkh->expire
    283       = GNUNET_TIME_absolute_to_timestamp (
    284           GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION));
    285   }
    286   switch (response_code)
    287   {
    288   case 0:
    289     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
    290                 "Failed to receive /keys response from exchange %s\n",
    291                 gkh->exchange_url);
    292     break;
    293   case MHD_HTTP_OK:
    294     if (NULL == j)
    295     {
    296       GNUNET_break (0);
    297       kresp.hr.http_status = 0;
    298       break;
    299     }
    300     kd = GNUNET_new (struct TALER_EXCHANGE_Keys);
    301     kd->exchange_url = GNUNET_strdup (gkh->exchange_url);
    302     if (NULL != gkh->prev_keys)
    303     {
    304       const struct TALER_EXCHANGE_Keys *kd_old = gkh->prev_keys;
    305 
    306       /* We keep the denomination keys and auditor signatures from the
    307          previous iteration (/keys cherry picking) */
    308       kd->num_denom_keys
    309         = kd_old->num_denom_keys;
    310       kd->last_denom_issue_date
    311         = kd_old->last_denom_issue_date;
    312       GNUNET_array_grow (kd->denom_keys,
    313                          kd->denom_keys_size,
    314                          kd->num_denom_keys);
    315       /* First make a shallow copy, we then need another pass for the RSA key... */
    316       GNUNET_memcpy (kd->denom_keys,
    317                      kd_old->denom_keys,
    318                      kd_old->num_denom_keys
    319                      * sizeof (struct TALER_EXCHANGE_DenomPublicKey));
    320       for (unsigned int i = 0; i<kd_old->num_denom_keys; i++)
    321         TALER_denom_pub_copy (&kd->denom_keys[i].key,
    322                               &kd_old->denom_keys[i].key);
    323       kd->num_auditors = kd_old->num_auditors;
    324       kd->auditors_size = kd_old->num_auditors;
    325       kd->auditors
    326         = GNUNET_new_array (kd->auditors_size,
    327                             struct TALER_EXCHANGE_AuditorInformation);
    328       /* Now the necessary deep copy... */
    329       for (unsigned int i = 0; i<kd_old->num_auditors; i++)
    330       {
    331         const struct TALER_EXCHANGE_AuditorInformation *aold =
    332           &kd_old->auditors[i];
    333         struct TALER_EXCHANGE_AuditorInformation *anew = &kd->auditors[i];
    334 
    335         anew->auditor_pub = aold->auditor_pub;
    336         anew->auditor_url = GNUNET_strdup (aold->auditor_url);
    337         anew->auditor_name = GNUNET_strdup (aold->auditor_name);
    338         GNUNET_array_grow (anew->denom_keys,
    339                            anew->num_denom_keys,
    340                            aold->num_denom_keys);
    341         GNUNET_memcpy (
    342           anew->denom_keys,
    343           aold->denom_keys,
    344           aold->num_denom_keys
    345           * sizeof (struct TALER_EXCHANGE_AuditorDenominationInfo));
    346       }
    347     }
    348     /* Now decode fresh /keys response */
    349     if (GNUNET_OK !=
    350         TALER_EXCHANGE_decode_keys_json_ (j,
    351                                           true,
    352                                           kd,
    353                                           &kresp.details.ok.compat))
    354     {
    355       TALER_LOG_ERROR ("Could not decode /keys response\n");
    356       kd->rc = 1;
    357       TALER_EXCHANGE_keys_decref (kd);
    358       kd = NULL;
    359       kresp.hr.http_status = 0;
    360       kresp.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
    361       break;
    362     }
    363     if (NULL != gkh->prev_keys)
    364     {
    365       const struct TALER_EXCHANGE_Keys *kd_old = gkh->prev_keys;
    366 
    367       /* The denominations and auditor signatures we cherry-picked from
    368          the previous response were validated against the master public
    369          key of that response; refuse to re-attribute them to a
    370          different master public key (or currency). */
    371       if ( (0 !=
    372             GNUNET_memcmp (&kd->master_pub,
    373                            &kd_old->master_pub)) ||
    374            (0 !=
    375             strcmp (kd->currency,
    376                     kd_old->currency)) )
    377       {
    378         GNUNET_break_op (0);
    379         TALER_LOG_ERROR (
    380           "Exchange changed master public key or currency in /keys\n");
    381         kd->rc = 1;
    382         TALER_EXCHANGE_keys_decref (kd);
    383         kd = NULL;
    384         kresp.hr.http_status = 0;
    385         kresp.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
    386         break;
    387       }
    388     }
    389     kd->rc = 1;
    390     kd->key_data_expiration = gkh->expire;
    391     if (GNUNET_TIME_relative_cmp (
    392           GNUNET_TIME_absolute_get_remaining (gkh->expire.abs_time),
    393           <,
    394           MINIMUM_EXPIRATION))
    395     {
    396       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
    397                   "Exchange returned keys with expiration time below %s. Compensating.\n",
    398                   GNUNET_TIME_relative2s (MINIMUM_EXPIRATION,
    399                                           true));
    400       kd->key_data_expiration
    401         = GNUNET_TIME_relative_to_timestamp (MINIMUM_EXPIRATION);
    402     }
    403 
    404     kresp.details.ok.keys = kd;
    405     break;
    406   case MHD_HTTP_BAD_REQUEST:
    407   case MHD_HTTP_UNAUTHORIZED:
    408   case MHD_HTTP_FORBIDDEN:
    409   case MHD_HTTP_NOT_FOUND:
    410     if (NULL == j)
    411     {
    412       kresp.hr.ec = TALER_EC_GENERIC_INVALID_RESPONSE;
    413       kresp.hr.hint = TALER_ErrorCode_get_hint (kresp.hr.ec);
    414     }
    415     else
    416     {
    417       kresp.hr.ec = TALER_JSON_get_error_code (j);
    418       kresp.hr.hint = TALER_JSON_get_error_hint (j);
    419     }
    420     break;
    421   default:
    422     if (NULL == j)
    423     {
    424       kresp.hr.ec = TALER_EC_GENERIC_INVALID_RESPONSE;
    425       kresp.hr.hint = TALER_ErrorCode_get_hint (kresp.hr.ec);
    426     }
    427     else
    428     {
    429       kresp.hr.ec = TALER_JSON_get_error_code (j);
    430       kresp.hr.hint = TALER_JSON_get_error_hint (j);
    431     }
    432     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
    433                 "Unexpected response code %u/%d\n",
    434                 (unsigned int) response_code,
    435                 (int) kresp.hr.ec);
    436     break;
    437   }
    438   gkh->cert_cb (gkh->cert_cb_cls,
    439                 &kresp,
    440                 kd);
    441   TALER_EXCHANGE_get_keys_cancel (gkh);
    442 }
    443 
    444 
    445 struct TALER_EXCHANGE_GetKeysHandle *
    446 TALER_EXCHANGE_get_keys_create (
    447   struct GNUNET_CURL_Context *ctx,
    448   const char *url)
    449 {
    450   struct TALER_EXCHANGE_GetKeysHandle *gkh;
    451 
    452   gkh = GNUNET_new (struct TALER_EXCHANGE_GetKeysHandle);
    453   gkh->ctx = ctx;
    454   gkh->exchange_url = GNUNET_strdup (url);
    455   return gkh;
    456 }
    457 
    458 
    459 enum GNUNET_GenericReturnValue
    460 TALER_EXCHANGE_get_keys_set_options_ (
    461   struct TALER_EXCHANGE_GetKeysHandle *gkh,
    462   unsigned int num_options,
    463   const struct TALER_EXCHANGE_GetKeysOptionValue *options)
    464 {
    465   for (unsigned int i = 0; i < num_options; i++)
    466   {
    467     const struct TALER_EXCHANGE_GetKeysOptionValue *opt = &options[i];
    468 
    469     switch (opt->option)
    470     {
    471     case TALER_EXCHANGE_GET_KEYS_OPTION_END:
    472       return GNUNET_OK;
    473     case TALER_EXCHANGE_GET_KEYS_OPTION_LAST_KEYS:
    474       TALER_EXCHANGE_keys_decref (gkh->prev_keys);
    475       gkh->prev_keys = NULL;
    476       if (NULL != opt->details.last_keys)
    477         gkh->prev_keys
    478           = TALER_EXCHANGE_keys_incref (opt->details.last_keys);
    479       break;
    480     }
    481   }
    482   return GNUNET_OK;
    483 }
    484 
    485 
    486 enum TALER_ErrorCode
    487 TALER_EXCHANGE_get_keys_start (
    488   struct TALER_EXCHANGE_GetKeysHandle *gkh,
    489   TALER_EXCHANGE_GetKeysCallback cert_cb,
    490   TALER_EXCHANGE_GET_KEYS_RESULT_CLOSURE *cert_cb_cls)
    491 {
    492   CURL *eh;
    493   char last_date[80] = { 0 };
    494 
    495   gkh->cert_cb = cert_cb;
    496   gkh->cert_cb_cls = cert_cb_cls;
    497   if (NULL != gkh->prev_keys)
    498   {
    499     TALER_LOG_DEBUG ("Last DK issue date (before GETting /keys): %s\n",
    500                      GNUNET_TIME_timestamp2s (
    501                        gkh->prev_keys->last_denom_issue_date));
    502     GNUNET_snprintf (last_date,
    503                      sizeof (last_date),
    504                      "%llu",
    505                      (unsigned long long)
    506                      gkh->prev_keys->last_denom_issue_date.abs_time.abs_value_us
    507                      / 1000000LLU);
    508   }
    509   gkh->url = TALER_url_join (gkh->exchange_url,
    510                              "keys",
    511                              (NULL != gkh->prev_keys)
    512                              ? "last_issue_date"
    513                              : NULL,
    514                              (NULL != gkh->prev_keys)
    515                              ? last_date
    516                              : NULL,
    517                              NULL);
    518   if (NULL == gkh->url)
    519   {
    520     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
    521                 "Could not construct request URL.\n");
    522     return TALER_EC_GENERIC_CONFIGURATION_INVALID;
    523   }
    524   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
    525               "Requesting keys with URL `%s'.\n",
    526               gkh->url);
    527   eh = TALER_EXCHANGE_curl_easy_get_ (gkh->url);
    528   if (NULL == eh)
    529   {
    530     GNUNET_break (0);
    531     GNUNET_free (gkh->url);
    532     gkh->url = NULL;
    533     return TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE;
    534   }
    535   GNUNET_break (CURLE_OK ==
    536                 curl_easy_setopt (eh,
    537                                   CURLOPT_VERBOSE,
    538                                   0));
    539   GNUNET_break (CURLE_OK ==
    540                 curl_easy_setopt (eh,
    541                                   CURLOPT_TIMEOUT,
    542                                   120 /* seconds */));
    543   GNUNET_assert (CURLE_OK ==
    544                  curl_easy_setopt (eh,
    545                                    CURLOPT_HEADERFUNCTION,
    546                                    &header_cb));
    547   GNUNET_assert (CURLE_OK ==
    548                  curl_easy_setopt (eh,
    549                                    CURLOPT_HEADERDATA,
    550                                    gkh));
    551   gkh->job = GNUNET_CURL_job_add_with_ct_json (gkh->ctx,
    552                                                eh,
    553                                                &keys_completed_cb,
    554                                                gkh);
    555   if (NULL == gkh->job)
    556   {
    557     GNUNET_free (gkh->url);
    558     gkh->url = NULL;
    559     return TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE;
    560   }
    561   return TALER_EC_NONE;
    562 }
    563 
    564 
    565 void
    566 TALER_EXCHANGE_get_keys_cancel (
    567   struct TALER_EXCHANGE_GetKeysHandle *gkh)
    568 {
    569   if (NULL != gkh->job)
    570   {
    571     GNUNET_CURL_job_cancel (gkh->job);
    572     gkh->job = NULL;
    573   }
    574   TALER_EXCHANGE_keys_decref (gkh->prev_keys);
    575   GNUNET_free (gkh->exchange_url);
    576   GNUNET_free (gkh->url);
    577   GNUNET_free (gkh);
    578 }
    579 
    580 
    581 /* end of exchange_api_get-keys.c */