luna - curl/lib/http_aws

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_AWS)
  27
  28#include "urldata.h"
  29#include "strcase.h"
  30#include "curlx/strdup.h"
  31#include "http_aws_sigv4.h"
  32#include "curl_sha256.h"
  33#include "transfer.h"
  34#include "curl_trc.h"
  35#include "escape.h"
  36#include "curlx/strparse.h"
  37#include "slist.h"
  38
  39#include <time.h>
  40
  41#define HMAC_SHA256(k, kl, d, dl, o)                 \
  42  do {                                               \
  43    result = Curl_hmacit(&Curl_HMAC_SHA256,          \
  44                         (const unsigned char *)(k), \
  45                         kl,                         \
  46                         (const unsigned char *)(d), \
  47                         dl, o);                     \
  48    if(result) {                                     \
  49      goto fail;                                     \
  50    }                                                \
  51  } while(0)
  52
  53#define TIMESTAMP_SIZE 17
  54
  55/* hex-encoded with trailing null */
  56#define SHA256_HEX_LENGTH ((2 * CURL_SHA256_DIGEST_LENGTH) + 1)
  57
  58#define MAX_QUERY_COMPONENTS 128
  59
  60struct pair {
  61  struct dynbuf key;
  62  struct dynbuf value;
  63};
  64
  65static void sha256_to_hex(char *dst, unsigned char *sha)
  66{
  67  Curl_hexencode(sha, CURL_SHA256_DIGEST_LENGTH,
  68                 (unsigned char *)dst, SHA256_HEX_LENGTH);
  69}
  70
  71static char *find_date_hdr(struct Curl_easy *data, const char *sig_hdr)
  72{
  73  char *tmp = Curl_checkheaders(data, sig_hdr, strlen(sig_hdr));
  74
  75  if(tmp)
  76    return tmp;
  77  return Curl_checkheaders(data, STRCONST("Date"));
  78}
  79
  80/* remove whitespace, and lowercase all headers */
  81static void trim_headers(struct curl_slist *head)
  82{
  83  struct curl_slist *l;
  84  for(l = head; l; l = l->next) {
  85    const char *value; /* to read from */
  86    char *store;
  87    size_t colon = strcspn(l->data, ":");
  88    Curl_strntolower(l->data, l->data, colon);
  89
  90    value = &l->data[colon];
  91    if(!*value)
  92      continue;
  93    ++value;
  94    store = (char *)CURL_UNCONST(value);
  95
  96    /* skip leading whitespace */
  97    curlx_str_passblanks(&value);
  98
  99    while(*value) {
 100      int space = 0;
 101      while(ISBLANK(*value)) {
 102        value++;
 103        space++;
 104      }
 105      if(space) {
 106        /* replace any number of consecutive whitespace with a single space,
 107           unless at the end of the string, then nothing */
 108        if(*value)
 109          *store++ = ' ';
 110      }
 111      else
 112        *store++ = *value++;
 113    }
 114    *store = 0; /* null-terminate */
 115  }
 116}
 117
 118/*
 119 * Frees all allocated strings in a dynbuf pair array, and the dynbuf itself
 120 */
 121static void pair_array_free(struct pair *pair_array, size_t num_elements)
 122{
 123  size_t index;
 124
 125  for(index = 0; index != num_elements; index++) {
 126    curlx_dyn_free(&pair_array[index].key);
 127    curlx_dyn_free(&pair_array[index].value);
 128  }
 129}
 130
 131/*
 132 * Frees all allocated strings in a split dynbuf, and the dynbuf itself
 133 */
 134static void dyn_array_free(struct dynbuf *db, size_t num_elements)
 135{
 136  size_t index;
 137
 138  for(index = 0; index < num_elements; index++)
 139    curlx_dyn_free((&db[index]));
 140}
 141
 142/*
 143 * Splits source string by SPLIT_BY, and creates an array of dynbuf in db.
 144 * db is initialized by this function.
 145 * Caller is responsible for freeing the array elements with dyn_array_free
 146 */
 147
 148#define SPLIT_BY '&'
 149
 150static CURLcode split_to_dyn_array(const char *source,
 151                                   struct dynbuf db[MAX_QUERY_COMPONENTS],
 152                                   size_t *num_splits_out)
 153{
 154  CURLcode result = CURLE_OK;
 155  size_t len = strlen(source);
 156  size_t pos;         /* Position in result buffer */
 157  size_t start = 0;   /* Start of current segment */
 158  size_t segment_length = 0;
 159  size_t index = 0;
 160  size_t num_splits = 0;
 161
 162  /* Split source_ptr on SPLIT_BY and store the segment offsets and length in
 163   * array */
 164  for(pos = 0; pos < len; pos++) {
 165    if(source[pos] == SPLIT_BY) {
 166      if(segment_length) {
 167        curlx_dyn_init(&db[index], segment_length + 1);
 168        result = curlx_dyn_addn(&db[index], &source[start], segment_length);
 169        if(result)
 170          goto fail;
 171
 172        segment_length = 0;
 173        index++;
 174        if(++num_splits == MAX_QUERY_COMPONENTS) {
 175          result = CURLE_TOO_LARGE;
 176          goto fail;
 177        }
 178      }
 179      start = pos + 1;
 180    }
 181    else {
 182      segment_length++;
 183    }
 184  }
 185
 186  if(segment_length) {
 187    curlx_dyn_init(&db[index], segment_length + 1);
 188    result = curlx_dyn_addn(&db[index], &source[start], segment_length);
 189    if(!result) {
 190      if(++num_splits == MAX_QUERY_COMPONENTS)
 191        result = CURLE_TOO_LARGE;
 192    }
 193  }
 194fail:
 195  *num_splits_out = num_splits;
 196  return result;
 197}
 198
 199static bool is_reserved_char(const char c)
 200{
 201  return (ISALNUM(c) || ISURLPUNTCS(c));
 202}
 203
 204static CURLcode uri_encode_path(struct Curl_str *original_path,
 205                                struct dynbuf *new_path)
 206{
 207  const char *p = curlx_str(original_path);
 208  size_t i;
 209
 210  for(i = 0; i < curlx_strlen(original_path); i++) {
 211    /* Do not encode slashes or unreserved chars from RFC 3986 */
 212    CURLcode result = CURLE_OK;
 213    unsigned char c = p[i];
 214    if(is_reserved_char(c) || c == '/')
 215      result = curlx_dyn_addn(new_path, &c, 1);
 216    else
 217      result = curlx_dyn_addf(new_path, "%%%02X", c);
 218    if(result)
 219      return result;
 220  }
 221
 222  return CURLE_OK;
 223}
 224
 225/* Normalize the query part. Make sure %2B is left percent encoded, and not
 226   decoded to plus, then encoded to space.
 227*/
 228static CURLcode normalize_query(const char *string, size_t len,
 229                                struct dynbuf *db)
 230{
 231  CURLcode result = CURLE_OK;
 232
 233  while(len && !result) {
 234    unsigned char in = (unsigned char)*string;
 235    if(('%' == in) && (len > 2) &&
 236       ISXDIGIT(string[1]) && ISXDIGIT(string[2])) {
 237      /* this is two hexadecimal digits following a '%' */
 238      in = (unsigned char)((curlx_hexval(string[1]) << 4) |
 239                           curlx_hexval(string[2]));
 240      string += 3;
 241      len -= 3;
 242      if(in == '+') {
 243        /* decodes to plus, so leave this encoded */
 244        result = curlx_dyn_addn(db, "%2B", 3);
 245        continue;
 246      }
 247    }
 248    else {
 249      string++;
 250      len--;
 251    }
 252
 253    if(is_reserved_char(in))
 254      /* Escape unreserved chars from RFC 3986 */
 255      result = curlx_dyn_addn(db, &in, 1);
 256    else if(in == '+')
 257      /* Encode '+' as space */
 258      result = curlx_dyn_add(db, "%20");
 259    else
 260      result = curlx_dyn_addf(db, "%%%02X", in);
 261  }
 262
 263  return result;
 264}
 265
 266static bool should_urlencode(struct Curl_str *service_name)
 267{
 268  /*
 269   * These services require unmodified (not additionally URL-encoded) URL
 270   * paths.
 271   * should_urlencode == true is equivalent to should_urlencode_uri_path
 272   * from the AWS SDK. Urls are already normalized by the curl URL parser
 273   */
 274
 275  if(curlx_str_cmp(service_name, "s3") ||
 276     curlx_str_cmp(service_name, "s3-express") ||
 277     curlx_str_cmp(service_name, "s3-outposts")) {
 278    return false;
 279  }
 280  return true;
 281}
 282
 283/* maximum length for the aws sivg4 parts */
 284#define MAX_SIGV4_LEN    64
 285#define DATE_HDR_KEY_LEN (MAX_SIGV4_LEN + sizeof("X--Date"))
 286
 287/* string been x-PROVIDER-date:TIMESTAMP, I need +1 for ':' */
 288#define DATE_FULL_HDR_LEN (DATE_HDR_KEY_LEN + TIMESTAMP_SIZE + 1)
 289
 290/* alphabetically compare two headers by their name, expecting
 291   headers to use ':' at this point */
 292static int compare_header_names(const char *a, const char *b)
 293{
 294  const char *colon_a;
 295  const char *colon_b;
 296  size_t len_a;
 297  size_t len_b;
 298  size_t min_len;
 299  int cmp;
 300
 301  colon_a = strchr(a, ':');
 302  colon_b = strchr(b, ':');
 303
 304  DEBUGASSERT(colon_a);
 305  DEBUGASSERT(colon_b);
 306
 307  len_a = colon_a ? (size_t)(colon_a - a) : strlen(a);
 308  len_b = colon_b ? (size_t)(colon_b - b) : strlen(b);
 309
 310  min_len = (len_a < len_b) ? len_a : len_b;
 311
 312  cmp = strncmp(a, b, min_len);
 313
 314  /* return the shorter of the two if one is shorter */
 315  if(!cmp)
 316    return (int)(len_a - len_b);
 317
 318  return cmp;
 319}
 320
 321/* Merge duplicate header definitions by comma delimiting their values
 322   in the order defined the headers are defined, expecting headers to
 323   be alpha-sorted and use ':' at this point */
 324static CURLcode merge_duplicate_headers(struct curl_slist *head)
 325{
 326  struct curl_slist *curr = head;
 327  CURLcode result = CURLE_OK;
 328
 329  while(curr) {
 330    struct curl_slist *next = curr->next;
 331    if(!next)
 332      break;
 333
 334    if(compare_header_names(curr->data, next->data) == 0) {
 335      struct dynbuf buf;
 336      const char *colon_next;
 337      const char *val_next;
 338
 339      curlx_dyn_init(&buf, CURL_MAX_HTTP_HEADER);
 340
 341      result = curlx_dyn_add(&buf, curr->data);
 342      if(result)
 343        return result;
 344
 345      colon_next = strchr(next->data, ':');
 346      DEBUGASSERT(colon_next);
 347      val_next = colon_next + 1;
 348
 349      result = curlx_dyn_addn(&buf, ",", 1);
 350      if(result)
 351        return result;
 352
 353      result = curlx_dyn_add(&buf, val_next);
 354      if(result)
 355        return result;
 356
 357      curlx_free(curr->data);
 358      curr->data = curlx_dyn_ptr(&buf);
 359
 360      curr->next = next->next;
 361      curlx_free(next->data);
 362      curlx_free(next);
 363    }
 364    else {
 365      curr = curr->next;
 366    }
 367  }
 368
 369  return CURLE_OK;
 370}
 371
 372/* timestamp should point to a buffer of at last TIMESTAMP_SIZE bytes */
 373static CURLcode make_headers(struct Curl_easy *data,
 374                             const char *hostname,
 375                             char *timestamp,
 376                             const char *provider1,
 377                             size_t plen, /* length of provider1 */
 378                             char **date_header,
 379                             char *content_sha256_header,
 380                             struct dynbuf *canonical_headers,
 381                             struct dynbuf *signed_headers)
 382{
 383  char date_hdr_key[DATE_HDR_KEY_LEN];
 384  char date_full_hdr[DATE_FULL_HDR_LEN];
 385  struct curl_slist *head = NULL;
 386  struct curl_slist *tmp_head = NULL;
 387  CURLcode ret = CURLE_OUT_OF_MEMORY;
 388  struct curl_slist *l;
 389  bool again = TRUE;
 390
 391  curl_msnprintf(date_hdr_key, DATE_HDR_KEY_LEN, "X-%.*s-Date",
 392                 (int)plen, provider1);
 393  /* provider1 ucfirst */
 394  Curl_strntolower(&date_hdr_key[2], provider1, plen);
 395  date_hdr_key[2] = Curl_raw_toupper(provider1[0]);
 396
 397  curl_msnprintf(date_full_hdr, DATE_FULL_HDR_LEN,
 398                 "x-%.*s-date:%s", (int)plen, provider1, timestamp);
 399  /* provider1 lowercase */
 400  Curl_strntolower(&date_full_hdr[2], provider1, plen);
 401
 402  if(!Curl_checkheaders(data, STRCONST("Host"))) {
 403    char *fullhost;
 404
 405    if(data->state.aptr.host) {
 406      /* remove /r/n as the separator for canonical request must be '\n' */
 407      size_t pos = strcspn(data->state.aptr.host, "\n\r");
 408      fullhost = curlx_memdup0(data->state.aptr.host, pos);
 409    }
 410    else
 411      fullhost = curl_maprintf("host:%s", hostname);
 412
 413    if(fullhost)
 414      head = Curl_slist_append_nodup(NULL, fullhost);
 415    if(!head) {
 416      curlx_free(fullhost);
 417      goto fail;
 418    }
 419  }
 420
 421  if(*content_sha256_header) {
 422    tmp_head = curl_slist_append(head, content_sha256_header);
 423    if(!tmp_head)
 424      goto fail;
 425    head = tmp_head;
 426  }
 427
 428  /* copy user headers to our header list. the logic is based on how http.c
 429     handles user headers.
 430
 431     user headers in format 'name:' with no value are used to signal that an
 432     internal header of that name should be removed. those user headers are not
 433     added to this list.
 434
 435     user headers in format 'name;' with no value are used to signal that a
 436     header of that name with no value should be sent. those user headers are
 437     added to this list but in the format that they will be sent, ie the
 438     semi-colon is changed to a colon for format 'name:'.
 439
 440     user headers with a value of whitespace only, or without a colon or
 441     semi-colon, are not added to this list.
 442     */
 443  for(l = data->set.headers; l; l = l->next) {
 444    char *dupdata;
 445    const char *ptr;
 446    const char *sep = strchr(l->data, ':');
 447    if(!sep)
 448      sep = strchr(l->data, ';');
 449    if(!sep || (*sep == ':' && !*(sep + 1)))
 450      continue;
 451    for(ptr = sep + 1; ISBLANK(*ptr); ++ptr)
 452      ;
 453    if(!*ptr && ptr != sep + 1) /* a value of whitespace only */
 454      continue;
 455    dupdata = curlx_strdup(l->data);
 456    if(!dupdata)
 457      goto fail;
 458    dupdata[sep - l->data] = ':';
 459    tmp_head = Curl_slist_append_nodup(head, dupdata);
 460    if(!tmp_head) {
 461      curlx_free(dupdata);
 462      goto fail;
 463    }
 464    head = tmp_head;
 465  }
 466
 467  trim_headers(head);
 468
 469  *date_header = find_date_hdr(data, date_hdr_key);
 470  if(!*date_header) {
 471    tmp_head = curl_slist_append(head, date_full_hdr);
 472    if(!tmp_head)
 473      goto fail;
 474    head = tmp_head;
 475    *date_header = curl_maprintf("%s: %s\r\n", date_hdr_key, timestamp);
 476    if(!*date_header)
 477      goto fail;
 478  }
 479  else {
 480    const char *value;
 481    const char *endp;
 482    value = strchr(*date_header, ':');
 483    if(!value) {
 484      *date_header = NULL;
 485      goto fail;
 486    }
 487    ++value;
 488    curlx_str_passblanks(&value);
 489    endp = value;
 490    while(*endp && ISALNUM(*endp))
 491      ++endp;
 492    /* 16 bytes => "19700101T000000Z" */
 493    if((endp - value) == TIMESTAMP_SIZE - 1) {
 494      memcpy(timestamp, value, TIMESTAMP_SIZE - 1);
 495      timestamp[TIMESTAMP_SIZE - 1] = 0;
 496    }
 497    else
 498      /* bad timestamp length */
 499      timestamp[0] = 0;
 500    *date_header = NULL;
 501  }
 502
 503  /* alpha-sort by header name in a case sensitive manner */
 504  do {
 505    again = FALSE;
 506    for(l = head; l; l = l->next) {
 507      struct curl_slist *next = l->next;
 508
 509      if(next && compare_header_names(l->data, next->data) > 0) {
 510        char *tmp = l->data;
 511
 512        l->data = next->data;
 513        next->data = tmp;
 514        again = TRUE;
 515      }
 516    }
 517  } while(again);
 518
 519  ret = merge_duplicate_headers(head);
 520  if(ret)
 521    goto fail;
 522
 523  for(l = head; l; l = l->next) {
 524    char *tmp;
 525
 526    if(curlx_dyn_add(canonical_headers, l->data))
 527      goto fail;
 528    if(curlx_dyn_add(canonical_headers, "\n"))
 529      goto fail;
 530
 531    tmp = strchr(l->data, ':');
 532    if(tmp)
 533      *tmp = 0;
 534
 535    if(l != head) {
 536      if(curlx_dyn_add(signed_headers, ";"))
 537        goto fail;
 538    }
 539    if(curlx_dyn_add(signed_headers, l->data))
 540      goto fail;
 541  }
 542
 543  ret = CURLE_OK;
 544fail:
 545  curl_slist_free_all(head);
 546
 547  return ret;
 548}
 549
 550#define CONTENT_SHA256_KEY_LEN (MAX_SIGV4_LEN + sizeof("X--Content-Sha256"))
 551/* add 2 for ": " between header name and value */
 552#define CONTENT_SHA256_HDR_LEN (CONTENT_SHA256_KEY_LEN + 2 + SHA256_HEX_LENGTH)
 553
 554/* try to parse a payload hash from the content-sha256 header */
 555static const char *parse_content_sha_hdr(struct Curl_easy *data,
 556                                         const char *provider1,
 557                                         size_t plen,
 558                                         size_t *value_len)
 559{
 560  char key[CONTENT_SHA256_KEY_LEN];
 561  size_t key_len;
 562  const char *value;
 563  size_t len;
 564
 565  key_len = curl_msnprintf(key, sizeof(key), "x-%.*s-content-sha256",
 566                           (int)plen, provider1);
 567
 568  value = Curl_checkheaders(data, key, key_len);
 569  if(!value)
 570    return NULL;
 571
 572  value = strchr(value, ':');
 573  if(!value)
 574    return NULL;
 575  ++value;
 576
 577  curlx_str_passblanks(&value);
 578
 579  len = strlen(value);
 580  while(len > 0 && ISBLANK(value[len - 1]))
 581    --len;
 582
 583  *value_len = len;
 584  return value;
 585}
 586
 587static CURLcode calc_payload_hash(struct Curl_easy *data,
 588                                  unsigned char *sha_hash, char *sha_hex)
 589{
 590  const char *post_data = data->set.postfields;
 591  size_t post_data_len = 0;
 592  CURLcode result;
 593
 594  if(post_data) {
 595    if(data->set.postfieldsize < 0)
 596      post_data_len = strlen(post_data);
 597    else
 598      post_data_len = (size_t)data->set.postfieldsize;
 599  }
 600  result = Curl_sha256it(sha_hash, (const unsigned char *)post_data,
 601                         post_data_len);
 602  if(!result)
 603    sha256_to_hex(sha_hex, sha_hash);
 604  return result;
 605}
 606
 607#define S3_UNSIGNED_PAYLOAD "UNSIGNED-PAYLOAD"
 608
 609static CURLcode calc_s3_payload_hash(struct Curl_easy *data,
 610                                     Curl_HttpReq httpreq,
 611                                     const char *provider1,
 612                                     size_t plen,
 613                                     unsigned char *sha_hash,
 614                                     char *sha_hex, char *header)
 615{
 616  bool empty_method = (httpreq == HTTPREQ_GET || httpreq == HTTPREQ_HEAD);
 617  /* The request method or filesize indicate no request payload */
 618  bool empty_payload = (empty_method || data->set.filesize == 0);
 619  /* The POST payload is in memory */
 620  bool post_payload = (httpreq == HTTPREQ_POST && data->set.postfields);
 621  CURLcode ret = CURLE_OUT_OF_MEMORY;
 622
 623  if(empty_payload || post_payload) {
 624    /* Calculate a real hash when we know the request payload */
 625    ret = calc_payload_hash(data, sha_hash, sha_hex);
 626    if(ret)
 627      goto fail;
 628  }
 629  else {
 630    /* Fall back to s3's UNSIGNED-PAYLOAD */
 631    size_t len = sizeof(S3_UNSIGNED_PAYLOAD) - 1;
 632    DEBUGASSERT(len < SHA256_HEX_LENGTH); /* 16 < 65 */
 633    memcpy(sha_hex, S3_UNSIGNED_PAYLOAD, len);
 634    sha_hex[len] = 0;
 635  }
 636
 637  /* format the required content-sha256 header */
 638  curl_msnprintf(header, CONTENT_SHA256_HDR_LEN,
 639                 "x-%.*s-content-sha256: %s", (int)plen, provider1, sha_hex);
 640
 641  ret = CURLE_OK;
 642fail:
 643  return ret;
 644}
 645
 646static int compare_func(const void *a, const void *b)
 647{
 648  const struct pair *aa = a;
 649  const struct pair *bb = b;
 650  const size_t aa_key_len = curlx_dyn_len(&aa->key);
 651  const size_t bb_key_len = curlx_dyn_len(&bb->key);
 652  const size_t aa_value_len = curlx_dyn_len(&aa->value);
 653  const size_t bb_value_len = curlx_dyn_len(&bb->value);
 654  int compare;
 655
 656  /* If one element is empty, the other is always sorted higher */
 657
 658  /* Compare keys */
 659  if((aa_key_len == 0) && (bb_key_len == 0))
 660    return 0;
 661  if(aa_key_len == 0)
 662    return -1;
 663  if(bb_key_len == 0)
 664    return 1;
 665  compare = strcmp(curlx_dyn_ptr(&aa->key), curlx_dyn_ptr(&bb->key));
 666  if(compare) {
 667    return compare;
 668  }
 669
 670  /* Compare values */
 671  if((aa_value_len == 0) && (bb_value_len == 0))
 672    return 0;
 673  if(aa_value_len == 0)
 674    return -1;
 675  if(bb_value_len == 0)
 676    return 1;
 677  compare = strcmp(curlx_dyn_ptr(&aa->value), curlx_dyn_ptr(&bb->value));
 678
 679  return compare;
 680}
 681
 682/* @unittest 1979 */
 683UNITTEST CURLcode canon_path(const char *q, size_t len,
 684                             struct dynbuf *new_path,
 685                             bool do_uri_encode);
 686UNITTEST CURLcode canon_path(const char *q, size_t len,
 687                             struct dynbuf *new_path,
 688                             bool do_uri_encode)
 689{
 690  CURLcode result = CURLE_OK;
 691
 692  struct Curl_str original_path;
 693
 694  curlx_str_assign(&original_path, q, len);
 695
 696  /* Normalized path will be either the same or shorter than the original
 697   * path, plus trailing slash */
 698
 699  if(do_uri_encode)
 700    result = uri_encode_path(&original_path, new_path);
 701  else
 702    result = curlx_dyn_addn(new_path, q, len);
 703
 704  if(!result) {
 705    if(curlx_dyn_len(new_path) == 0)
 706      result = curlx_dyn_add(new_path, "/");
 707  }
 708
 709  return result;
 710}
 711
 712/* @unittest 1980 */
 713UNITTEST CURLcode canon_query(const char *query, struct dynbuf *dq);
 714UNITTEST CURLcode canon_query(const char *query, struct dynbuf *dq)
 715{
 716  CURLcode result = CURLE_OK;
 717
 718  struct dynbuf query_array[MAX_QUERY_COMPONENTS];
 719  struct pair encoded_query_array[MAX_QUERY_COMPONENTS];
 720  size_t num_query_components;
 721  size_t counted_query_components = 0;
 722  size_t index;
 723
 724  if(!query)
 725    return result;
 726
 727  result = split_to_dyn_array(query, &query_array[0], &num_query_components);
 728  if(result) {
 729    goto fail;
 730  }
 731
 732  /* Create list of pairs, each pair containing an encoded query
 733   * component */
 734
 735  for(index = 0; index < num_query_components; index++) {
 736    const char *in_key;
 737    size_t in_key_len;
 738    const char *offset;
 739    size_t query_part_len = curlx_dyn_len(&query_array[index]);
 740    const char *query_part = curlx_dyn_ptr(&query_array[index]);
 741
 742    in_key = query_part;
 743
 744    offset = strchr(query_part, '=');
 745    /* If there is no equals, this key has no value */
 746    if(!offset) {
 747      in_key_len = strlen(in_key);
 748    }
 749    else {
 750      in_key_len = offset - in_key;
 751    }
 752
 753    curlx_dyn_init(&encoded_query_array[index].key,
 754      (query_part_len * 3) + 1);
 755    curlx_dyn_init(&encoded_query_array[index].value,
 756      (query_part_len * 3) + 1);
 757    counted_query_components++;
 758
 759    /* Decode/encode the key */
 760    result = normalize_query(in_key, in_key_len,
 761                             &encoded_query_array[index].key);
 762    if(result) {
 763      goto fail;
 764    }
 765
 766    /* Decode/encode the value if it exists */
 767    if(offset && offset != (query_part + query_part_len - 1)) {
 768      size_t in_value_len;
 769      const char *in_value = offset + 1;
 770      in_value_len = query_part + query_part_len - (offset + 1);
 771      result = normalize_query(in_value, in_value_len,
 772                               &encoded_query_array[index].value);
 773      if(result) {
 774        goto fail;
 775      }
 776    }
 777    else {
 778      /* If there is no value, the value is an empty string */
 779      curlx_dyn_init(&encoded_query_array[index].value, 2);
 780      result = curlx_dyn_addn(&encoded_query_array[index].value, "", 1);
 781    }
 782
 783    if(result) {
 784      goto fail;
 785    }
 786  }
 787
 788  /* Sort the encoded query components by key and value */
 789  qsort(&encoded_query_array, num_query_components,
 790        sizeof(struct pair), compare_func);
 791
 792  /* Append the query components together to make a full query string */
 793  for(index = 0; index < num_query_components; index++) {
 794
 795    if(index)
 796      result = curlx_dyn_addn(dq, "&", 1);
 797    if(!result) {
 798      const char *key_ptr = curlx_dyn_ptr(&encoded_query_array[index].key);
 799      const char *value_ptr = curlx_dyn_ptr(&encoded_query_array[index].value);
 800      size_t vlen = curlx_dyn_len(&encoded_query_array[index].value);
 801      if(value_ptr && vlen) {
 802        result = curlx_dyn_addf(dq, "%s=%s", key_ptr, value_ptr);
 803      }
 804      else {
 805        /* Empty value is always encoded to key= */
 806        result = curlx_dyn_addf(dq, "%s=", key_ptr);
 807      }
 808    }
 809    if(result)
 810      break;
 811  }
 812
 813fail:
 814  if(counted_query_components)
 815    /* the encoded_query_array might not be initialized yet */
 816    pair_array_free(&encoded_query_array[0], counted_query_components);
 817  dyn_array_free(&query_array[0], num_query_components);
 818  return result;
 819}
 820
 821CURLcode Curl_output_aws_sigv4(struct Curl_easy *data)
 822{
 823  CURLcode result = CURLE_OUT_OF_MEMORY;
 824  struct connectdata *conn = data->conn;
 825  const char *line;
 826  struct Curl_str provider0;
 827  struct Curl_str provider1;
 828  struct Curl_str region = { NULL, 0 };
 829  struct Curl_str service = { NULL, 0 };
 830  const char *hostname = conn->origin->hostname;
 831  time_t clock;
 832  struct tm tm;
 833  char timestamp[TIMESTAMP_SIZE];
 834  char date[9];
 835  struct dynbuf canonical_headers;
 836  struct dynbuf signed_headers;
 837  struct dynbuf canonical_query;
 838  struct dynbuf canonical_path;
 839  char *date_header = NULL;
 840  Curl_HttpReq httpreq;
 841  const char *method = NULL;
 842  const char *payload_hash = NULL;
 843  size_t payload_hash_len = 0;
 844  unsigned char sha_hash[CURL_SHA256_DIGEST_LENGTH];
 845  char sha_hex[SHA256_HEX_LENGTH];
 846  char content_sha256_hdr[CONTENT_SHA256_HDR_LEN + 2] = ""; /* add \r\n */
 847  char *canonical_request = NULL;
 848  char *request_type = NULL;
 849  char *credential_scope = NULL;
 850  char *str_to_sign = NULL;
 851  const char *user = Curl_creds_user(data->state.creds);
 852  const char *passwd = Curl_creds_passwd(data->state.creds);
 853  char *secret = NULL;
 854  unsigned char sign0[CURL_SHA256_DIGEST_LENGTH] = { 0 };
 855  unsigned char sign1[CURL_SHA256_DIGEST_LENGTH] = { 0 };
 856  char *auth_headers = NULL;
 857
 858  if(data->set.path_as_is) {
 859    failf(data, "Cannot use sigv4 authentication with path-as-is flag");
 860    return CURLE_BAD_FUNCTION_ARGUMENT;
 861  }
 862
 863  if(Curl_checkheaders(data, STRCONST("Authorization"))) {
 864    /* Authorization already present, Bailing out */
 865    return CURLE_OK;
 866  }
 867
 868  /* we init those buffers here, so goto fail will free initialized dynbuf */
 869  curlx_dyn_init(&canonical_headers, CURL_MAX_HTTP_HEADER);
 870  curlx_dyn_init(&canonical_query, CURL_MAX_HTTP_HEADER);
 871  curlx_dyn_init(&signed_headers, CURL_MAX_HTTP_HEADER);
 872  curlx_dyn_init(&canonical_path, CURL_MAX_HTTP_HEADER);
 873
 874  /*
 875   * Parameters parsing
 876   * Google and Outscale use the same OSC or GOOG,
 877   * but Amazon uses AWS and AMZ for header arguments.
 878   * AWS is the default because most of non-amazon providers
 879   * are still using aws:amz as a prefix.
 880   */
 881  line = data->set.str[STRING_AWS_SIGV4];
 882  if(!line || !*line)
 883    line = "aws:amz";
 884
 885  /* provider0[:provider1[:region[:service]]]
 886
 887     No string can be longer than N bytes of non-whitespace
 888  */
 889  if(curlx_str_until(&line, &provider0, MAX_SIGV4_LEN, ':')) {
 890    failf(data, "first aws-sigv4 provider cannot be empty");
 891    result = CURLE_BAD_FUNCTION_ARGUMENT;
 892    goto fail;
 893  }
 894  if(curlx_str_single(&line, ':') ||
 895     curlx_str_until(&line, &provider1, MAX_SIGV4_LEN, ':')) {
 896    provider1 = provider0;
 897  }
 898  else if(curlx_str_single(&line, ':') ||
 899          curlx_str_until(&line, &region, MAX_SIGV4_LEN, ':') ||
 900          curlx_str_single(&line, ':') ||
 901          curlx_str_until(&line, &service, MAX_SIGV4_LEN, ':')) {
 902    /* nothing to do */
 903  }
 904
 905  if(!curlx_strlen(&service)) {
 906    const char *p = hostname;
 907    if(curlx_str_until(&p, &service, MAX_SIGV4_LEN, '.') ||
 908       curlx_str_single(&p, '.')) {
 909      failf(data, "aws-sigv4: service missing in parameters and hostname");
 910      result = CURLE_URL_MALFORMAT;
 911      goto fail;
 912    }
 913
 914    infof(data, "aws_sigv4: picked service %.*s from host",
 915          (int)curlx_strlen(&service), curlx_str(&service));
 916
 917    if(!curlx_strlen(&region)) {
 918      if(curlx_str_until(&p, &region, MAX_SIGV4_LEN, '.') ||
 919         curlx_str_single(&p, '.')) {
 920        failf(data, "aws-sigv4: region missing in parameters and hostname");
 921        result = CURLE_URL_MALFORMAT;
 922        goto fail;
 923      }
 924      infof(data, "aws_sigv4: picked region %.*s from host",
 925            (int)curlx_strlen(&region), curlx_str(&region));
 926    }
 927  }
 928
 929  Curl_http_method(data, &method, &httpreq);
 930
 931  payload_hash =
 932    parse_content_sha_hdr(data, curlx_str(&provider1),
 933                          curlx_strlen(&provider1), &payload_hash_len);
 934
 935  if(!payload_hash) {
 936    /* AWS S3 requires a x-amz-content-sha256 header, and supports special
 937     * values like UNSIGNED-PAYLOAD */
 938    bool sign_as_s3 = curlx_str_casecompare(&provider0, "aws") &&
 939                      curlx_str_casecompare(&service, "s3");
 940
 941    if(sign_as_s3)
 942      result = calc_s3_payload_hash(data, httpreq, curlx_str(&provider1),
 943                                    curlx_strlen(&provider1), sha_hash,
 944                                    sha_hex, content_sha256_hdr);
 945    else
 946      result = calc_payload_hash(data, sha_hash, sha_hex);
 947    if(result)
 948      goto fail;
 949
 950    payload_hash = sha_hex;
 951    /* may be shorter than SHA256_HEX_LENGTH, like S3_UNSIGNED_PAYLOAD */
 952    payload_hash_len = strlen(sha_hex);
 953  }
 954
 955#ifdef DEBUGBUILD
 956  {
 957    char *force_timestamp = getenv("CURL_FORCETIME");
 958    if(force_timestamp)
 959      clock = 0;
 960    else
 961      clock = time(NULL);
 962  }
 963#else
 964  clock = time(NULL);
 965#endif
 966  result = curlx_gmtime(clock, &tm);
 967  if(result) {
 968    goto fail;
 969  }
 970  if(!strftime(timestamp, sizeof(timestamp), "%Y%m%dT%H%M%SZ", &tm)) {
 971    result = CURLE_OUT_OF_MEMORY;
 972    goto fail;
 973  }
 974
 975  result = make_headers(data, hostname, timestamp,
 976                        curlx_str(&provider1), curlx_strlen(&provider1),
 977                        &date_header, content_sha256_hdr,
 978                        &canonical_headers, &signed_headers);
 979  if(result)
 980    goto fail;
 981
 982  if(*content_sha256_hdr) {
 983    /* make_headers() needed this without the \r\n for canonicalization */
 984    size_t hdrlen = strlen(content_sha256_hdr);
 985    DEBUGASSERT(hdrlen + 3 < sizeof(content_sha256_hdr));
 986    memcpy(content_sha256_hdr + hdrlen, "\r\n", 3);
 987  }
 988
 989  memcpy(date, timestamp, sizeof(date));
 990  date[sizeof(date) - 1] = 0;
 991
 992  result = canon_query(data->state.up.query, &canonical_query);
 993  if(result)
 994    goto fail;
 995
 996  result = canon_path(data->state.up.path, strlen(data->state.up.path),
 997                      &canonical_path,
 998                      should_urlencode(&service));
 999  if(result)
1000    goto fail;
1001  result = CURLE_OUT_OF_MEMORY;
1002
1003  canonical_request =
1004    curl_maprintf("%s\n" /* HTTPRequestMethod */
1005                  "%s\n" /* CanonicalURI */
1006                  "%s\n" /* CanonicalQueryString */
1007                  "%s\n" /* CanonicalHeaders */
1008                  "%s\n" /* SignedHeaders */
1009                  "%.*s",  /* HashedRequestPayload in hex */
1010                  method,
1011                  curlx_dyn_ptr(&canonical_path),
1012                  curlx_dyn_ptr(&canonical_query) ?
1013                  curlx_dyn_ptr(&canonical_query) : "",
1014                  curlx_dyn_ptr(&canonical_headers),
1015                  curlx_dyn_ptr(&signed_headers),
1016                  (int)payload_hash_len, payload_hash);
1017  if(!canonical_request)
1018    goto fail;
1019
1020  infof(data, "aws_sigv4: Canonical request (enclosed in []) - [%s]",
1021        canonical_request);
1022
1023  request_type = curl_maprintf("%.*s4_request",
1024                               (int)curlx_strlen(&provider0),
1025                               curlx_str(&provider0));
1026  if(!request_type)
1027    goto fail;
1028
1029  /* provider0 is lowercased *after* curl_maprintf() so that the buffer
1030     can be written to */
1031  Curl_strntolower(request_type, request_type, curlx_strlen(&provider0));
1032
1033  credential_scope = curl_maprintf("%s/%.*s/%.*s/%s", date,
1034                                   (int)curlx_strlen(&region),
1035                                   curlx_str(&region),
1036                                   (int)curlx_strlen(&service),
1037                                   curlx_str(&service),
1038                                   request_type);
1039  if(!credential_scope)
1040    goto fail;
1041
1042  if(Curl_sha256it(sha_hash, (unsigned char *)canonical_request,
1043                   strlen(canonical_request)))
1044    goto fail;
1045
1046  sha256_to_hex(sha_hex, sha_hash);
1047
1048  /*
1049   * Google allows using RSA key instead of HMAC, so this code might change
1050   * in the future. For now we only support HMAC.
1051   */
1052  str_to_sign = curl_maprintf("%.*s4-HMAC-SHA256\n" /* Algorithm */
1053                              "%s\n" /* RequestDateTime */
1054                              "%s\n" /* CredentialScope */
1055                              "%s",  /* HashedCanonicalRequest in hex */
1056                              (int)curlx_strlen(&provider0),
1057                              curlx_str(&provider0),
1058                              timestamp,
1059                              credential_scope,
1060                              sha_hex);
1061  if(!str_to_sign)
1062    goto fail;
1063
1064  /* make provider0 part done uppercase */
1065  Curl_strntoupper(str_to_sign, curlx_str(&provider0),
1066                   curlx_strlen(&provider0));
1067
1068  infof(data, "aws_sigv4: String to sign (enclosed in []) - [%s]",
1069        str_to_sign);
1070
1071  secret = curl_maprintf("%.*s4%s", (int)curlx_strlen(&provider0),
1072                         curlx_str(&provider0), passwd);
1073  if(!secret)
1074    goto fail;
1075  /* make provider0 part done uppercase */
1076  Curl_strntoupper(secret, curlx_str(&provider0), curlx_strlen(&provider0));
1077
1078  HMAC_SHA256(secret, strlen(secret), date, strlen(date), sign0);
1079  HMAC_SHA256(sign0, sizeof(sign0),
1080              curlx_str(&region), curlx_strlen(&region), sign1);
1081  HMAC_SHA256(sign1, sizeof(sign1),
1082              curlx_str(&service), curlx_strlen(&service), sign0);
1083  HMAC_SHA256(sign0, sizeof(sign0), request_type, strlen(request_type), sign1);
1084  HMAC_SHA256(sign1, sizeof(sign1), str_to_sign, strlen(str_to_sign), sign0);
1085
1086  sha256_to_hex(sha_hex, sign0);
1087
1088  infof(data, "aws_sigv4: Signature - %s", sha_hex);
1089
1090  auth_headers = curl_maprintf("Authorization: %.*s4-HMAC-SHA256 "
1091                               "Credential=%s/%s, "
1092                               "SignedHeaders=%s, "
1093                               "Signature=%s\r\n"
1094                               /*
1095                                * date_header is added here, only if it was not
1096                                * user-specified (using CURLOPT_HTTPHEADER).
1097                                * date_header includes \r\n
1098                                */
1099                               "%s"
1100                               "%s", /* optional sha256 header includes \r\n */
1101                               (int)curlx_strlen(&provider0),
1102                               curlx_str(&provider0),
1103                               user,
1104                               credential_scope,
1105                               curlx_dyn_ptr(&signed_headers),
1106                               sha_hex,
1107                               date_header ? date_header : "",
1108                               content_sha256_hdr);
1109  if(!auth_headers) {
1110    goto fail;
1111  }
1112  /* provider 0 uppercase */
1113  Curl_strntoupper(&auth_headers[sizeof("Authorization: ") - 1],
1114                   curlx_str(&provider0), curlx_strlen(&provider0));
1115
1116  curlx_free(data->req.hd_auth);
1117  data->req.hd_auth = auth_headers;
1118  data->state.authhost.done = TRUE;
1119  result = CURLE_OK;
1120
1121fail:
1122  curlx_dyn_free(&canonical_query);
1123  curlx_dyn_free(&canonical_path);
1124  curlx_dyn_free(&canonical_headers);
1125  curlx_dyn_free(&signed_headers);
1126  curlx_free(canonical_request);
1127  curlx_free(request_type);
1128  curlx_free(credential_scope);
1129  curlx_free(str_to_sign);
1130  curlx_free(secret);
1131  curlx_free(date_header);
1132  return result;
1133}
1134
1135#endif /* !CURL_DISABLE_HTTP && !CURL_DISABLE_AWS */