luna - curl/lib/vauth/digest.c

   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 * RFC2831 DIGEST-MD5 authentication
  24 * RFC7616 DIGEST-SHA256, DIGEST-SHA512-256 authentication
  25 *
  26 ***************************************************************************/
  27#include "curl_setup.h"
  28
  29#ifndef CURL_DISABLE_DIGEST_AUTH
  30
  31#include "vauth/vauth.h"
  32#include "vauth/digest.h"
  33#include "curlx/base64.h"
  34#include "curl_md5.h"
  35#include "curl_sha256.h"
  36#include "curl_sha512_256.h"
  37#include "curlx/strparse.h"
  38#include "rand.h"
  39
  40#ifndef USE_WINDOWS_SSPI
  41#define SESSION_ALGO 1 /* for algos with this bit set */
  42
  43#define ALGO_MD5 0
  44#define ALGO_MD5SESS (ALGO_MD5 | SESSION_ALGO)
  45#define ALGO_SHA256 2
  46#define ALGO_SHA256SESS (ALGO_SHA256 | SESSION_ALGO)
  47#define ALGO_SHA512_256 4
  48#define ALGO_SHA512_256SESS (ALGO_SHA512_256 | SESSION_ALGO)
  49
  50#define DIGEST_QOP_VALUE_AUTH             (1 << 0)
  51#define DIGEST_QOP_VALUE_AUTH_INT         (1 << 1)
  52#define DIGEST_QOP_VALUE_AUTH_CONF        (1 << 2)
  53
  54#define DIGEST_QOP_VALUE_STRING_AUTH      "auth"
  55#define DIGEST_QOP_VALUE_STRING_AUTH_INT  "auth-int"
  56#define DIGEST_QOP_VALUE_STRING_AUTH_CONF "auth-conf"
  57#endif
  58
  59bool Curl_auth_digest_get_pair(const char *str, char *value, char *content,
  60                               const char **endptr)
  61{
  62  int c;
  63  bool starts_with_quote = FALSE;
  64  bool escape = FALSE;
  65
  66  for(c = DIGEST_MAX_VALUE_LENGTH - 1; (*str && (*str != '=') && c--);)
  67    *value++ = *str++;
  68  *value = 0;
  69
  70  if('=' != *str++)
  71    /* eek, no match */
  72    return FALSE;
  73
  74  if('\"' == *str) {
  75    /* This starts with a quote so it must end with one as well! */
  76    str++;
  77    starts_with_quote = TRUE;
  78  }
  79
  80  for(c = DIGEST_MAX_CONTENT_LENGTH - 1; *str && c--; str++) {
  81    if(!escape) {
  82      switch(*str) {
  83      case '\\':
  84        if(starts_with_quote) {
  85          /* the start of an escaped quote */
  86          escape = TRUE;
  87          continue;
  88        }
  89        break;
  90
  91      case ',':
  92        if(!starts_with_quote) {
  93          /* This signals the end of the content if we did not get a starting
  94             quote and then we do "sloppy" parsing */
  95          c = 0; /* the end */
  96          continue;
  97        }
  98        break;
  99
 100      case '\r':
 101      case '\n':
 102        /* end of string */
 103        if(starts_with_quote)
 104          return FALSE; /* No closing quote */
 105        c = 0;
 106        continue;
 107
 108      case '\"':
 109        if(starts_with_quote) {
 110          /* end of string */
 111          c = 0;
 112          continue;
 113        }
 114        else
 115          return FALSE;
 116      }
 117    }
 118
 119    escape = FALSE;
 120    *content++ = *str;
 121  }
 122  if(escape)
 123    return FALSE; /* No character after backslash */
 124
 125  *content = 0;
 126  *endptr = str;
 127
 128  return TRUE;
 129}
 130
 131#ifndef USE_WINDOWS_SSPI
 132/* Convert MD5 chunk to RFC2617 (section 3.1.3) -suitable ASCII string */
 133static void auth_digest_md5_to_ascii(
 134  const unsigned char *source, /* 16 bytes */
 135  unsigned char *dest)         /* 33 bytes */
 136{
 137  int i;
 138  for(i = 0; i < 16; i++)
 139    curl_msnprintf((char *)&dest[i * 2], 3, "%02x", source[i]);
 140}
 141
 142/* Convert sha256 or SHA-512/256 chunk to RFC7616 -suitable ASCII string */
 143static void auth_digest_sha256_to_ascii(
 144  const unsigned char *source, /* 32 bytes */
 145  unsigned char *dest)         /* 65 bytes */
 146{
 147  int i;
 148  for(i = 0; i < 32; i++)
 149    curl_msnprintf((char *)&dest[i * 2], 3, "%02x", source[i]);
 150}
 151
 152/* Perform quoted-string escaping as described in RFC2616 and its errata */
 153static char *auth_digest_string_quoted(const char *s)
 154{
 155  struct dynbuf out;
 156  curlx_dyn_init(&out, 2048);
 157  if(!*s) /* for zero length input, make sure we return an empty string */
 158    return curlx_strdup("");
 159  while(*s) {
 160    CURLcode result;
 161    if(*s == '"' || *s == '\\') {
 162      result = curlx_dyn_addn(&out, "\\", 1);
 163      if(!result)
 164        result = curlx_dyn_addn(&out, s, 1);
 165    }
 166    else
 167      result = curlx_dyn_addn(&out, s, 1);
 168    if(result)
 169      return NULL;
 170    s++;
 171  }
 172  return curlx_dyn_ptr(&out);
 173}
 174
 175/* Retrieves the value for a corresponding key from the challenge string
 176 * returns TRUE if the key could be found, FALSE if it does not exists
 177 */
 178static bool auth_digest_get_key_value(const char *chlg, const char *key,
 179                                      char *buf, size_t buflen)
 180{
 181  /* keyword=[value],keyword2=[value]
 182     The values may or may not be quoted.
 183   */
 184
 185  do {
 186    struct Curl_str data;
 187    struct Curl_str name;
 188
 189    curlx_str_passblanks(&chlg);
 190
 191    if(!curlx_str_until(&chlg, &name, 64, '=') &&
 192       !curlx_str_single(&chlg, '=')) {
 193      /* this is the key, get the value, possibly quoted */
 194      int rc = curlx_str_quotedword(&chlg, &data, 256);
 195      if(rc == STRE_BEGQUOTE)
 196        /* try unquoted until comma */
 197        rc = curlx_str_until(&chlg, &data, 256, ',');
 198      if(rc)
 199        return FALSE; /* weird */
 200
 201      if(curlx_str_cmp(&name, key)) {
 202        /* if this is our key, return the value */
 203        size_t len = curlx_strlen(&data);
 204        const char *src = curlx_str(&data);
 205        size_t i;
 206        size_t outlen = 0;
 207
 208        if(len >= buflen)
 209          /* does not fit */
 210          return FALSE;
 211
 212        for(i = 0; i < len; i++) {
 213          if(src[i] == '\\' && i + 1 < len) {
 214            i++; /* skip backslash */
 215          }
 216          buf[outlen++] = src[i];
 217        }
 218        buf[outlen] = 0;
 219        return TRUE;
 220      }
 221      if(curlx_str_single(&chlg, ','))
 222        return FALSE;
 223    }
 224    else /* odd syntax */
 225      break;
 226  } while(1);
 227
 228  return FALSE;
 229}
 230
 231static void auth_digest_get_qop_values(const char *options, int *value)
 232{
 233  struct Curl_str out;
 234  /* Initialize the output */
 235  *value = 0;
 236
 237  while(!curlx_str_until(&options, &out, 32, ',')) {
 238    if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
 239      *value |= DIGEST_QOP_VALUE_AUTH;
 240    else if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_INT))
 241      *value |= DIGEST_QOP_VALUE_AUTH_INT;
 242    else if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_CONF))
 243      *value |= DIGEST_QOP_VALUE_AUTH_CONF;
 244    if(curlx_str_single(&options, ','))
 245      break;
 246  }
 247}
 248
 249/*
 250 * auth_decode_digest_md5_message()
 251 *
 252 * This is used internally to decode an already encoded DIGEST-MD5 challenge
 253 * message into the separate attributes.
 254 *
 255 * Parameters:
 256 *
 257 * chlgref [in]     - The challenge message.
 258 * nonce   [in/out] - The buffer where the nonce is stored.
 259 * nlen    [in]     - The length of the nonce buffer.
 260 * realm   [in/out] - The buffer where the realm is stored.
 261 * rlen    [in]     - The length of the realm buffer.
 262 * alg     [in/out] - The buffer where the algorithm is stored.
 263 * alen    [in]     - The length of the algorithm buffer.
 264 * qop     [in/out] - The buffer where the qop-options is stored.
 265 * qlen    [in]     - The length of the qop buffer.
 266 *
 267 * Returns CURLE_OK on success.
 268 */
 269static CURLcode auth_decode_digest_md5_message(const struct bufref *chlgref,
 270                                               char *nonce, size_t nlen,
 271                                               char *realm, size_t rlen,
 272                                               char *alg, size_t alen,
 273                                               char *qop, size_t qlen)
 274{
 275  const char *chlg = Curl_bufref_ptr(chlgref);
 276
 277  /* Ensure we have a valid challenge message */
 278  if(!Curl_bufref_len(chlgref))
 279    return CURLE_BAD_CONTENT_ENCODING;
 280
 281  /* Retrieve nonce string from the challenge */
 282  if(!auth_digest_get_key_value(chlg, "nonce", nonce, nlen))
 283    return CURLE_BAD_CONTENT_ENCODING;
 284
 285  /* Retrieve realm string from the challenge */
 286  if(!auth_digest_get_key_value(chlg, "realm", realm, rlen)) {
 287    /* Challenge does not have a realm, set empty string [RFC2831] page 6 */
 288    *realm = '\0';
 289  }
 290
 291  /* Retrieve algorithm string from the challenge */
 292  if(!auth_digest_get_key_value(chlg, "algorithm", alg, alen))
 293    return CURLE_BAD_CONTENT_ENCODING;
 294
 295  /* Retrieve qop-options string from the challenge */
 296  if(!auth_digest_get_key_value(chlg, "qop", qop, qlen))
 297    return CURLE_BAD_CONTENT_ENCODING;
 298
 299  return CURLE_OK;
 300}
 301
 302/*
 303 * Curl_auth_is_digest_supported()
 304 *
 305 * This is used to evaluate if DIGEST is supported.
 306 *
 307 * Parameters: None
 308 *
 309 * Returns TRUE as DIGEST as handled by libcurl.
 310 */
 311bool Curl_auth_is_digest_supported(void)
 312{
 313  return TRUE;
 314}
 315
 316/*
 317 * Curl_auth_create_digest_md5_message()
 318 *
 319 * This is used to generate an already encoded DIGEST-MD5 response message
 320 * ready for sending to the recipient.
 321 *
 322 * Parameters:
 323 *
 324 * data    [in]     - The session handle.
 325 * chlg    [in]     - The challenge message.
 326 * userp   [in]     - The username.
 327 * passwdp [in]     - The user's password.
 328 * service [in]     - The service type such as http, smtp, pop or imap.
 329 * out     [out]    - The result storage.
 330 *
 331 * Returns CURLE_OK on success.
 332 */
 333CURLcode Curl_auth_create_digest_md5_message(struct Curl_easy *data,
 334                                             const struct bufref *chlg,
 335                                             struct Curl_creds *creds,
 336                                             const char *default_service,
 337                                             struct bufref *out)
 338{
 339  const char *service = Curl_creds_has_sasl_service(creds) ?
 340    Curl_creds_sasl_service(creds) : default_service;
 341  size_t i;
 342  struct MD5_context *ctxt;
 343  const char *userp = Curl_creds_user(creds);
 344  const char *passwdp = Curl_creds_passwd(creds);
 345  char *response = NULL;
 346  unsigned char digest[MD5_DIGEST_LEN];
 347  char HA1_hex[(2 * MD5_DIGEST_LEN) + 1];
 348  char HA2_hex[(2 * MD5_DIGEST_LEN) + 1];
 349  char resp_hash_hex[(2 * MD5_DIGEST_LEN) + 1];
 350  char nonce[64];
 351  char realm[128];
 352  char algorithm[64];
 353  char qop_options[64];
 354  int qop_values;
 355  char cnonce[33];
 356  char nonceCount[] = "00000001";
 357  char method[]     = "AUTHENTICATE";
 358  char qop[]        = DIGEST_QOP_VALUE_STRING_AUTH;
 359  char *spn         = NULL;
 360  char *qrealm;
 361  char *qnonce;
 362  char *quserp;
 363
 364  /* Decode the challenge message */
 365  CURLcode result = auth_decode_digest_md5_message(chlg,
 366                                                   nonce, sizeof(nonce),
 367                                                   realm, sizeof(realm),
 368                                                   algorithm,
 369                                                   sizeof(algorithm),
 370                                                   qop_options,
 371                                                   sizeof(qop_options));
 372  if(result)
 373    return result;
 374
 375  /* We only support md5 sessions */
 376  if(strcmp(algorithm, "md5-sess") != 0)
 377    return CURLE_BAD_CONTENT_ENCODING;
 378
 379  /* Get the qop-values from the qop-options */
 380  auth_digest_get_qop_values(qop_options, &qop_values);
 381
 382  /* We only support auth quality-of-protection */
 383  if(!(qop_values & DIGEST_QOP_VALUE_AUTH))
 384    return CURLE_BAD_CONTENT_ENCODING;
 385
 386  /* Generate 32 random hex chars, 32 bytes + 1 null-termination */
 387  result = Curl_rand_hex(data, (unsigned char *)cnonce, sizeof(cnonce));
 388  if(result)
 389    return result;
 390
 391  /* Good so far, now calculate A1 and H(A1) according to RFC 2831 */
 392  ctxt = Curl_MD5_init(&Curl_DIGEST_MD5);
 393  if(!ctxt)
 394    return CURLE_OUT_OF_MEMORY;
 395
 396  Curl_MD5_update(ctxt, (const unsigned char *)userp,
 397                  curlx_uztoui(strlen(userp)));
 398  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 399  Curl_MD5_update(ctxt, (const unsigned char *)realm,
 400                  curlx_uztoui(strlen(realm)));
 401  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 402  Curl_MD5_update(ctxt, (const unsigned char *)passwdp,
 403                  curlx_uztoui(strlen(passwdp)));
 404  Curl_MD5_final(ctxt, digest);
 405
 406  ctxt = Curl_MD5_init(&Curl_DIGEST_MD5);
 407  if(!ctxt)
 408    return CURLE_OUT_OF_MEMORY;
 409
 410  Curl_MD5_update(ctxt, (const unsigned char *)digest, MD5_DIGEST_LEN);
 411  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 412  Curl_MD5_update(ctxt, (const unsigned char *)nonce,
 413                  curlx_uztoui(strlen(nonce)));
 414  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 415  Curl_MD5_update(ctxt, (const unsigned char *)cnonce,
 416                  curlx_uztoui(strlen(cnonce)));
 417  Curl_MD5_final(ctxt, digest);
 418
 419  /* Convert calculated 16 octet hex into 32 bytes string */
 420  for(i = 0; i < MD5_DIGEST_LEN; i++)
 421    curl_msnprintf(&HA1_hex[2 * i], 3, "%02x", digest[i]);
 422
 423  /* Generate our SPN */
 424  spn = Curl_auth_build_spn(service, data->conn->origin->hostname, NULL);
 425  if(!spn)
 426    return CURLE_OUT_OF_MEMORY;
 427
 428  /* Calculate H(A2) */
 429  ctxt = Curl_MD5_init(&Curl_DIGEST_MD5);
 430  if(!ctxt) {
 431    curlx_free(spn);
 432
 433    return CURLE_OUT_OF_MEMORY;
 434  }
 435
 436  Curl_MD5_update(ctxt, (const unsigned char *)method,
 437                  curlx_uztoui(strlen(method)));
 438  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 439  Curl_MD5_update(ctxt, (const unsigned char *)spn,
 440                  curlx_uztoui(strlen(spn)));
 441  Curl_MD5_final(ctxt, digest);
 442
 443  for(i = 0; i < MD5_DIGEST_LEN; i++)
 444    curl_msnprintf(&HA2_hex[2 * i], 3, "%02x", digest[i]);
 445
 446  /* Now calculate the response hash */
 447  ctxt = Curl_MD5_init(&Curl_DIGEST_MD5);
 448  if(!ctxt) {
 449    curlx_free(spn);
 450
 451    return CURLE_OUT_OF_MEMORY;
 452  }
 453
 454  Curl_MD5_update(ctxt, (const unsigned char *)HA1_hex, 2 * MD5_DIGEST_LEN);
 455  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 456  Curl_MD5_update(ctxt, (const unsigned char *)nonce,
 457                  curlx_uztoui(strlen(nonce)));
 458  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 459
 460  Curl_MD5_update(ctxt, (const unsigned char *)nonceCount,
 461                  curlx_uztoui(strlen(nonceCount)));
 462  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 463  Curl_MD5_update(ctxt, (const unsigned char *)cnonce,
 464                  curlx_uztoui(strlen(cnonce)));
 465  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 466  Curl_MD5_update(ctxt, (const unsigned char *)qop,
 467                  curlx_uztoui(strlen(qop)));
 468  Curl_MD5_update(ctxt, (const unsigned char *)":", 1);
 469
 470  Curl_MD5_update(ctxt, (const unsigned char *)HA2_hex, 2 * MD5_DIGEST_LEN);
 471  Curl_MD5_final(ctxt, digest);
 472
 473  for(i = 0; i < MD5_DIGEST_LEN; i++)
 474    curl_msnprintf(&resp_hash_hex[2 * i], 3, "%02x", digest[i]);
 475
 476  /* escape double quotes and backslashes in the username, realm and nonce as
 477     necessary */
 478  qrealm = auth_digest_string_quoted(realm);
 479  qnonce = auth_digest_string_quoted(nonce);
 480  quserp = auth_digest_string_quoted(userp);
 481  if(qrealm && qnonce && quserp)
 482    /* Generate the response */
 483    response = curl_maprintf("username=\"%s\",realm=\"%s\",nonce=\"%s\","
 484                             "cnonce=\"%s\",nc=\"%s\",digest-uri=\"%s\","
 485                             "response=%s,qop=%s",
 486                             quserp, qrealm, qnonce,
 487                             cnonce, nonceCount, spn, resp_hash_hex, qop);
 488
 489  curlx_free(qrealm);
 490  curlx_free(qnonce);
 491  curlx_free(quserp);
 492  curlx_free(spn);
 493  if(!response)
 494    return CURLE_OUT_OF_MEMORY;
 495
 496  /* Return the response. */
 497  Curl_bufref_set(out, response, strlen(response), curl_free);
 498  return result;
 499}
 500
 501/*
 502 * Curl_auth_decode_digest_http_message()
 503 *
 504 * This is used to decode an HTTP DIGEST challenge message into the separate
 505 * attributes.
 506 *
 507 * Parameters:
 508 *
 509 * chlg    [in]     - The challenge message.
 510 * digest  [in/out] - The digest data struct being used and modified.
 511 *
 512 * Returns CURLE_OK on success.
 513 */
 514CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
 515                                              struct digestdata *digest)
 516{
 517  bool before = FALSE; /* got a nonce before */
 518
 519  /* If we already have received a nonce, keep that in mind */
 520  if(digest->nonce)
 521    before = TRUE;
 522
 523  /* Clean up any former leftovers and initialize to defaults */
 524  Curl_auth_digest_cleanup(digest);
 525
 526  for(;;) {
 527    char value[DIGEST_MAX_VALUE_LENGTH];
 528    char content[DIGEST_MAX_CONTENT_LENGTH];
 529
 530    /* Pass all additional spaces here */
 531    while(*chlg && ISBLANK(*chlg))
 532      chlg++;
 533
 534    /* Extract a value=content pair */
 535    if(Curl_auth_digest_get_pair(chlg, value, content, &chlg)) {
 536      if(curl_strequal(value, "nonce")) {
 537        curlx_free(digest->nonce);
 538        digest->nonce = curlx_strdup(content);
 539        if(!digest->nonce)
 540          return CURLE_OUT_OF_MEMORY;
 541      }
 542      else if(curl_strequal(value, "stale")) {
 543        if(curl_strequal(content, "true")) {
 544          digest->stale = TRUE;
 545          digest->nc = 1; /* we make a new nonce now */
 546        }
 547      }
 548      else if(curl_strequal(value, "realm")) {
 549        curlx_free(digest->realm);
 550        digest->realm = curlx_strdup(content);
 551        if(!digest->realm)
 552          return CURLE_OUT_OF_MEMORY;
 553      }
 554      else if(curl_strequal(value, "opaque")) {
 555        curlx_free(digest->opaque);
 556        digest->opaque = curlx_strdup(content);
 557        if(!digest->opaque)
 558          return CURLE_OUT_OF_MEMORY;
 559      }
 560      else if(curl_strequal(value, "qop")) {
 561        const char *token = content;
 562        struct Curl_str out;
 563        bool foundAuth = FALSE;
 564        bool foundAuthInt = FALSE;
 565        /* Pass leading spaces */
 566        while(*token && ISBLANK(*token))
 567          token++;
 568        while(!curlx_str_until(&token, &out, 32, ',')) {
 569          if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
 570            foundAuth = TRUE;
 571          else if(curlx_str_casecompare(&out,
 572                                        DIGEST_QOP_VALUE_STRING_AUTH_INT))
 573            foundAuthInt = TRUE;
 574          if(curlx_str_single(&token, ','))
 575            break;
 576          while(*token && ISBLANK(*token))
 577            token++;
 578        }
 579
 580        /* Select only auth or auth-int. Otherwise, ignore */
 581        if(foundAuth) {
 582          curlx_free(digest->qop);
 583          digest->qop = curlx_strdup(DIGEST_QOP_VALUE_STRING_AUTH);
 584          if(!digest->qop)
 585            return CURLE_OUT_OF_MEMORY;
 586        }
 587        else if(foundAuthInt) {
 588          curlx_free(digest->qop);
 589          digest->qop = curlx_strdup(DIGEST_QOP_VALUE_STRING_AUTH_INT);
 590          if(!digest->qop)
 591            return CURLE_OUT_OF_MEMORY;
 592        }
 593      }
 594      else if(curl_strequal(value, "algorithm")) {
 595        curlx_free(digest->algorithm);
 596        digest->algorithm = curlx_strdup(content);
 597        if(!digest->algorithm)
 598          return CURLE_OUT_OF_MEMORY;
 599
 600        if(curl_strequal(content, "MD5-sess"))
 601          digest->algo = ALGO_MD5SESS;
 602        else if(curl_strequal(content, "MD5"))
 603          digest->algo = ALGO_MD5;
 604        else if(curl_strequal(content, "SHA-256"))
 605          digest->algo = ALGO_SHA256;
 606        else if(curl_strequal(content, "SHA-256-SESS"))
 607          digest->algo = ALGO_SHA256SESS;
 608        else if(curl_strequal(content, "SHA-512-256")) {
 609#ifdef CURL_HAVE_SHA512_256
 610          digest->algo = ALGO_SHA512_256;
 611#else /* !CURL_HAVE_SHA512_256 */
 612          return CURLE_NOT_BUILT_IN;
 613#endif /* CURL_HAVE_SHA512_256 */
 614        }
 615        else if(curl_strequal(content, "SHA-512-256-SESS")) {
 616#ifdef CURL_HAVE_SHA512_256
 617          digest->algo = ALGO_SHA512_256SESS;
 618#else /* !CURL_HAVE_SHA512_256 */
 619          return CURLE_NOT_BUILT_IN;
 620#endif /* CURL_HAVE_SHA512_256 */
 621        }
 622        else
 623          return CURLE_BAD_CONTENT_ENCODING;
 624      }
 625      else if(curl_strequal(value, "userhash")) {
 626        if(curl_strequal(content, "true")) {
 627          digest->userhash = TRUE;
 628        }
 629      }
 630      else {
 631        /* Unknown specifier, ignore it! */
 632      }
 633    }
 634    else
 635      break; /* We are done here */
 636
 637    /* Pass all additional spaces here */
 638    while(*chlg && ISBLANK(*chlg))
 639      chlg++;
 640
 641    /* Allow the list to be comma-separated */
 642    if(',' == *chlg)
 643      chlg++;
 644  }
 645
 646  /* We had a nonce since before, and we got another one now without
 647     'stale=true'. This means we provided bad credentials in the previous
 648     request */
 649  if(before && !digest->stale)
 650    return CURLE_BAD_CONTENT_ENCODING;
 651
 652  /* We got this header without a nonce, that is a bad Digest line! */
 653  if(!digest->nonce)
 654    return CURLE_BAD_CONTENT_ENCODING;
 655
 656  /* "<algo>-sess" protocol versions require "auth" or "auth-int" qop */
 657  if(!digest->qop && (digest->algo & SESSION_ALGO))
 658    return CURLE_BAD_CONTENT_ENCODING;
 659
 660  return CURLE_OK;
 661}
 662
 663/*
 664 * auth_create_digest_http_message()
 665 *
 666 * This is used to generate an HTTP DIGEST response message ready for sending
 667 * to the recipient.
 668 *
 669 * Parameters:
 670 *
 671 * data    [in]     - The session handle.
 672 * creds   [in]     - The credentials
 673 * request [in]     - The HTTP request.
 674 * uripath [in]     - The path of the HTTP uri.
 675 * digest  [in/out] - The digest data struct being used and modified.
 676 * outptr  [in/out] - The address where a pointer to newly allocated memory
 677 *                    holding the result is stored upon completion.
 678 * outlen  [out]    - The length of the output message.
 679 *
 680 * Returns CURLE_OK on success.
 681 */
 682static CURLcode auth_create_digest_http_message(
 683  struct Curl_easy *data,
 684  struct Curl_creds *creds,
 685  const unsigned char *request,
 686  const unsigned char *uripath,
 687  struct digestdata *digest,
 688  char **outptr, size_t *outlen,
 689  void (*convert_to_ascii)(const unsigned char *, unsigned char *),
 690  CURLcode (*hash)(unsigned char *, const unsigned char *, const size_t))
 691{
 692  CURLcode result;
 693  const char *userp = Curl_creds_user(creds);
 694  const char *passwdp = Curl_creds_passwd(creds);
 695  unsigned char hashbuf[32]; /* 32 bytes/256 bits */
 696  unsigned char request_digest[65];
 697  unsigned char ha1[65];    /* 64 digits and 1 zero byte */
 698  unsigned char ha2[65];    /* 64 digits and 1 zero byte */
 699  char userh[65];
 700  char *cnonce = NULL;
 701  size_t cnonce_sz = 0;
 702  char *userp_quoted = NULL;
 703  char *realm_quoted = NULL;
 704  char *nonce_quoted = NULL;
 705  char *hashthis = NULL;
 706  char *uri_quoted = NULL;
 707  struct dynbuf response;
 708  *outptr = NULL;
 709
 710  curlx_dyn_init(&response, 4096); /* arbitrary max */
 711
 712  memset(hashbuf, 0, sizeof(hashbuf));
 713  if(!digest->nc)
 714    digest->nc = 1;
 715
 716  if(!digest->cnonce) {
 717    char cnoncebuf[12];
 718    result = Curl_rand_bytes(data,
 719#ifdef DEBUGBUILD
 720                             TRUE,
 721#endif
 722                             (unsigned char *)cnoncebuf,
 723                             sizeof(cnoncebuf));
 724    if(!result)
 725      result = curlx_base64_encode((uint8_t *)cnoncebuf, sizeof(cnoncebuf),
 726                                   &cnonce, &cnonce_sz);
 727    if(result)
 728      goto oom;
 729
 730    digest->cnonce = cnonce;
 731  }
 732
 733  if(digest->userhash) {
 734    char *hasht = curl_maprintf("%s:%s", userp,
 735                                digest->realm ? digest->realm : "");
 736    if(!hasht) {
 737      result = CURLE_OUT_OF_MEMORY;
 738      goto oom;
 739    }
 740
 741    result = hash(hashbuf, (unsigned char *)hasht, strlen(hasht));
 742    curlx_free(hasht);
 743    if(result)
 744      goto oom;
 745    convert_to_ascii(hashbuf, (unsigned char *)userh);
 746  }
 747
 748  /*
 749    If the algorithm is "MD5" or unspecified (which then defaults to MD5):
 750
 751      A1 = unq(username-value) ":" unq(realm-value) ":" passwd
 752
 753    If the algorithm is "MD5-sess" then:
 754
 755      A1 = H(unq(username-value) ":" unq(realm-value) ":" passwd) ":"
 756           unq(nonce-value) ":" unq(cnonce-value)
 757  */
 758
 759  hashthis = curl_maprintf("%s:%s:%s", userp, digest->realm ?
 760                           digest->realm : "", passwdp);
 761  if(!hashthis) {
 762    result = CURLE_OUT_OF_MEMORY;
 763    goto oom;
 764  }
 765
 766  result = hash(hashbuf, (unsigned char *)hashthis, strlen(hashthis));
 767  curlx_free(hashthis);
 768  if(result)
 769    goto oom;
 770  convert_to_ascii(hashbuf, ha1);
 771
 772  if(digest->algo & SESSION_ALGO) {
 773    /* nonce and cnonce are OUTSIDE the hash */
 774    char *tmp = curl_maprintf("%s:%s:%s", ha1, digest->nonce, digest->cnonce);
 775    if(!tmp) {
 776      result = CURLE_OUT_OF_MEMORY;
 777      goto oom;
 778    }
 779
 780    result = hash(hashbuf, (unsigned char *)tmp, strlen(tmp));
 781    curlx_free(tmp);
 782    if(result)
 783      goto oom;
 784    convert_to_ascii(hashbuf, ha1);
 785  }
 786
 787  /*
 788    If the "qop" directive's value is "auth" or is unspecified, then A2 is:
 789
 790      A2 = Method ":" digest-uri-value
 791
 792    If the "qop" value is "auth-int", then A2 is:
 793
 794      A2 = Method ":" digest-uri-value ":" H(entity-body)
 795
 796    (The "Method" value is the HTTP request method as specified in section
 797    5.1.1 of RFC 2616)
 798  */
 799
 800  uri_quoted = auth_digest_string_quoted((const char *)uripath);
 801  if(!uri_quoted) {
 802    result = CURLE_OUT_OF_MEMORY;
 803    goto oom;
 804  }
 805
 806  hashthis = curl_maprintf("%s:%s", request, uripath);
 807  if(!hashthis) {
 808    result = CURLE_OUT_OF_MEMORY;
 809    goto oom;
 810  }
 811
 812  if(digest->qop && curl_strequal(digest->qop, "auth-int")) {
 813    /* We do not support auth-int for PUT or POST */
 814    char hashed[65];
 815    char *hashthis2;
 816
 817    result = hash(hashbuf, (const unsigned char *)"", 0);
 818    if(result) {
 819      curlx_free(hashthis);
 820      goto oom;
 821    }
 822    convert_to_ascii(hashbuf, (unsigned char *)hashed);
 823
 824    hashthis2 = curl_maprintf("%s:%s", hashthis, hashed);
 825    curlx_free(hashthis);
 826    hashthis = hashthis2;
 827    if(!hashthis) {
 828      result = CURLE_OUT_OF_MEMORY;
 829      goto oom;
 830    }
 831  }
 832
 833  result = hash(hashbuf, (unsigned char *)hashthis, strlen(hashthis));
 834  curlx_free(hashthis);
 835  if(result)
 836    goto oom;
 837  convert_to_ascii(hashbuf, ha2);
 838
 839  if(digest->qop)
 840    hashthis = curl_maprintf("%s:%s:%08x:%s:%s:%s", ha1, digest->nonce,
 841                             digest->nc, digest->cnonce, digest->qop, ha2);
 842  else
 843    hashthis = curl_maprintf("%s:%s:%s", ha1, digest->nonce, ha2);
 844
 845  if(!hashthis) {
 846    result = CURLE_OUT_OF_MEMORY;
 847    goto oom;
 848  }
 849
 850  result = hash(hashbuf, (unsigned char *)hashthis, strlen(hashthis));
 851  curlx_free(hashthis);
 852  if(result)
 853    goto oom;
 854  convert_to_ascii(hashbuf, request_digest);
 855
 856  /* For test case 64 (snooped from a Mozilla 1.3a request)
 857
 858     Authorization: Digest username="testuser", realm="testrealm", \
 859     nonce="1053604145", uri="/64", response="c55f7f30d83d774a3d2dcacf725abaca"
 860
 861     Digest parameters are all quoted strings. Username which is provided by
 862     the user needs double quotes and backslashes within it escaped.
 863     realm, nonce, and opaque needs backslashes as well as they were
 864     de-escaped when copied from request header. cnonce is generated with
 865     web-safe characters. uri is already percent encoded. nc is 8 hex
 866     characters. algorithm and qop with standard values only contain web-safe
 867     characters.
 868  */
 869  userp_quoted = auth_digest_string_quoted(digest->userhash ? userh : userp);
 870  if(!userp_quoted) {
 871    result = CURLE_OUT_OF_MEMORY;
 872    goto oom;
 873  }
 874  if(digest->realm)
 875    realm_quoted = auth_digest_string_quoted(digest->realm);
 876  else {
 877    realm_quoted = curlx_malloc(1);
 878    if(realm_quoted)
 879      realm_quoted[0] = 0;
 880  }
 881  if(!realm_quoted) {
 882    result = CURLE_OUT_OF_MEMORY;
 883    goto oom;
 884  }
 885
 886  nonce_quoted = auth_digest_string_quoted(digest->nonce);
 887  if(!nonce_quoted) {
 888    result = CURLE_OUT_OF_MEMORY;
 889    goto oom;
 890  }
 891
 892  if(digest->qop) {
 893    result = curlx_dyn_addf(&response, "username=\"%s\", "
 894                            "realm=\"%s\", "
 895                            "nonce=\"%s\", "
 896                            "uri=\"%s\", "
 897                            "cnonce=\"%s\", "
 898                            "nc=%08x, "
 899                            "qop=%s, "
 900                            "response=\"%s\"",
 901                            userp_quoted,
 902                            realm_quoted,
 903                            nonce_quoted,
 904                            uri_quoted,
 905                            digest->cnonce,
 906                            digest->nc,
 907                            digest->qop,
 908                            request_digest);
 909
 910    /* Increment nonce-count to use another nc value for the next request */
 911    digest->nc++;
 912  }
 913  else {
 914    result = curlx_dyn_addf(&response, "username=\"%s\", "
 915                            "realm=\"%s\", "
 916                            "nonce=\"%s\", "
 917                            "uri=\"%s\", "
 918                            "response=\"%s\"",
 919                            userp_quoted,
 920                            realm_quoted,
 921                            nonce_quoted,
 922                            uri_quoted,
 923                            request_digest);
 924  }
 925  if(result)
 926    goto oom;
 927
 928  /* Add the optional fields */
 929  if(digest->opaque) {
 930    /* Append the opaque */
 931    char *opaque_quoted = auth_digest_string_quoted(digest->opaque);
 932    if(!opaque_quoted) {
 933      result = CURLE_OUT_OF_MEMORY;
 934      goto oom;
 935    }
 936    result = curlx_dyn_addf(&response, ", opaque=\"%s\"", opaque_quoted);
 937    curlx_free(opaque_quoted);
 938    if(result)
 939      goto oom;
 940  }
 941
 942  if(digest->algorithm) {
 943    /* Append the algorithm */
 944    result = curlx_dyn_addf(&response, ", algorithm=%s", digest->algorithm);
 945    if(result)
 946      goto oom;
 947  }
 948
 949  if(digest->userhash) {
 950    /* Append the userhash */
 951    result = curlx_dyn_add(&response, ", userhash=true");
 952    if(result)
 953      goto oom;
 954  }
 955
 956  /* Return the output */
 957  *outptr = curlx_dyn_ptr(&response);
 958  *outlen = curlx_dyn_len(&response);
 959  result = CURLE_OK;
 960
 961oom:
 962  curlx_free(nonce_quoted);
 963  curlx_free(realm_quoted);
 964  curlx_free(uri_quoted);
 965  curlx_free(userp_quoted);
 966  if(result)
 967    curlx_dyn_free(&response);
 968  return result;
 969}
 970
 971/*
 972 * Curl_auth_create_digest_http_message()
 973 *
 974 * This is used to generate an HTTP DIGEST response message ready for sending
 975 * to the recipient.
 976 *
 977 * Parameters:
 978 *
 979 * data    [in]     - The session handle.
 980 * userp   [in]     - The username.
 981 * passwdp [in]     - The user's password.
 982 * request [in]     - The HTTP request.
 983 * uripath [in]     - The path of the HTTP uri.
 984 * digest  [in/out] - The digest data struct being used and modified.
 985 * outptr  [in/out] - The address where a pointer to newly allocated memory
 986 *                    holding the result is stored upon completion.
 987 * outlen  [out]    - The length of the output message.
 988 *
 989 * Returns CURLE_OK on success.
 990 */
 991CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
 992                                              struct Curl_creds *creds,
 993                                              const unsigned char *request,
 994                                              const unsigned char *uripath,
 995                                              struct digestdata *digest,
 996                                              char **outptr, size_t *outlen)
 997{
 998  if(digest->algo <= ALGO_MD5SESS)
 999    return auth_create_digest_http_message(data, creds,
1000                                           request, uripath, digest,
1001                                           outptr, outlen,
1002                                           auth_digest_md5_to_ascii,
1003                                           Curl_md5it);
1004
1005  if(digest->algo <= ALGO_SHA256SESS)
1006    return auth_create_digest_http_message(data, creds,
1007                                           request, uripath, digest,
1008                                           outptr, outlen,
1009                                           auth_digest_sha256_to_ascii,
1010                                           Curl_sha256it);
1011#ifdef CURL_HAVE_SHA512_256
1012  if(digest->algo <= ALGO_SHA512_256SESS)
1013    return auth_create_digest_http_message(data, creds,
1014                                           request, uripath, digest,
1015                                           outptr, outlen,
1016                                           auth_digest_sha256_to_ascii,
1017                                           Curl_sha512_256it);
1018#endif /* CURL_HAVE_SHA512_256 */
1019
1020  /* Should be unreachable */
1021  return CURLE_BAD_CONTENT_ENCODING;
1022}
1023
1024/*
1025 * Curl_auth_digest_cleanup()
1026 *
1027 * This is used to clean up the digest specific data.
1028 *
1029 * Parameters:
1030 *
1031 * digest    [in/out] - The digest data struct being cleaned up.
1032 *
1033 */
1034void Curl_auth_digest_cleanup(struct digestdata *digest)
1035{
1036  curlx_safefree(digest->nonce);
1037  curlx_safefree(digest->cnonce);
1038  curlx_safefree(digest->realm);
1039  curlx_safefree(digest->opaque);
1040  curlx_safefree(digest->qop);
1041  curlx_safefree(digest->algorithm);
1042
1043  digest->nc = 0;
1044  digest->algo = ALGO_MD5; /* default algorithm */
1045  digest->stale = FALSE;   /* default means normal, not stale */
1046  digest->userhash = FALSE;
1047}
1048#endif /* !USE_WINDOWS_SSPI */
1049
1050#endif /* !CURL_DISABLE_DIGEST_AUTH */