lib/vauth/digest_sspi.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 2014 - 2016, Steve Holme, <steve_holme@hotmail.com>.
   9  * Copyright (C) 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
  10  *
  11  * This software is licensed as described in the file COPYING, which
  12  * you should have received as part of this distribution. The terms
  13  * are also available at https://curl.haxx.se/docs/copyright.html.
  14  *
  15  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  16  * copies of the Software, and permit persons to whom the Software is
  17  * furnished to do so, under the terms of the COPYING file.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  * RFC2831 DIGEST-MD5 authentication
  23  *
  24  ***************************************************************************/
  25
  26 #include "curl_setup.h"
  27
  28 #if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_CRYPTO_AUTH)
  29
  30 #include <curl/curl.h>
  31
  32 #include "vauth/vauth.h"
  33 #include "vauth/digest.h"
  34 #include "urldata.h"
  35 #include "curl_base64.h"
  36 #include "warnless.h"
  37 #include "curl_multibyte.h"
  38 #include "sendf.h"
  39 #include "strdup.h"
  40 #include "strcase.h"
  41
  42 /* The last #include files should be: */
  43 #include "curl_memory.h"
  44 #include "memdebug.h"
  45
  46 /*
  47 * Curl_auth_is_digest_supported()
  48 *
  49 * This is used to evaluate if DIGEST is supported.
  50 *
  51 * Parameters: None
  52 *
  53 * Returns TRUE if DIGEST is supported by Windows SSPI.
  54 */
  55 bool Curl_auth_is_digest_supported(void)
  56 {
  57   PSecPkgInfo SecurityPackage;
  58   SECURITY_STATUS status;
  59
  60   /* Query the security package for Digest */
  61   status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
  62                                               &SecurityPackage);
  63
  64   return (status == SEC_E_OK ? TRUE : FALSE);
  65 }
  66
  67 /*
  68  * Curl_auth_create_digest_md5_message()
  69  *
  70  * This is used to generate an already encoded DIGEST-MD5 response message
  71  * ready for sending to the recipient.
  72  *
  73  * Parameters:
  74  *
  75  * data    [in]     - The session handle.
  76  * chlg64  [in]     - The base64 encoded challenge message.
  77  * userp   [in]     - The user name in the format User or Domain\User.
  78  * passdwp [in]     - The user's password.
  79  * service [in]     - The service type such as http, smtp, pop or imap.
  80  * outptr  [in/out] - The address where a pointer to newly allocated memory
  81  *                    holding the result will be stored upon completion.
  82  * outlen  [out]    - The length of the output message.
  83  *
  84  * Returns CURLE_OK on success.
  85  */
  86 CURLcode Curl_auth_create_digest_md5_message(struct Curl_easy *data,
  87                                              const char *chlg64,
  88                                              const char *userp,
  89                                              const char *passwdp,
  90                                              const char *service,
  91                                              char **outptr, size_t *outlen)
  92 {
  93   CURLcode result = CURLE_OK;
  94   TCHAR *spn = NULL;
  95   size_t chlglen = 0;
  96   size_t token_max = 0;
  97   unsigned char *input_token = NULL;
  98   unsigned char *output_token = NULL;
  99   CredHandle credentials;
 100   CtxtHandle context;
 101   PSecPkgInfo SecurityPackage;
 102   SEC_WINNT_AUTH_IDENTITY identity;
 103   SEC_WINNT_AUTH_IDENTITY *p_identity;
 104   SecBuffer chlg_buf;
 105   SecBuffer resp_buf;
 106   SecBufferDesc chlg_desc;
 107   SecBufferDesc resp_desc;
 108   SECURITY_STATUS status;
 109   unsigned long attrs;
 110   TimeStamp expiry; /* For Windows 9x compatibility of SSPI calls */
 111
 112   /* Decode the base-64 encoded challenge message */
 113   if(strlen(chlg64) && *chlg64 != '=') {
 114     result = Curl_base64_decode(chlg64, &input_token, &chlglen);
 115     if(result)
 116       return result;
 117   }
 118
 119   /* Ensure we have a valid challenge message */
 120   if(!input_token) {
 121     infof(data, "DIGEST-MD5 handshake failure (empty challenge message)\n");
 122
 123     return CURLE_BAD_CONTENT_ENCODING;
 124   }
 125
 126   /* Query the security package for DigestSSP */
 127   status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
 128                                               &SecurityPackage);
 129   if(status != SEC_E_OK) {
 130     free(input_token);
 131
 132     return CURLE_NOT_BUILT_IN;
 133   }
 134
 135   token_max = SecurityPackage->cbMaxToken;
 136
 137   /* Release the package buffer as it is not required anymore */
 138   s_pSecFn->FreeContextBuffer(SecurityPackage);
 139
 140   /* Allocate our response buffer */
 141   output_token = malloc(token_max);
 142   if(!output_token) {
 143     free(input_token);
 144
 145     return CURLE_OUT_OF_MEMORY;
 146   }
 147
 148   /* Generate our SPN */
 149   spn = Curl_auth_build_spn(service, data->easy_conn->host.name, NULL);
 150   if(!spn) {
 151     free(output_token);
 152     free(input_token);
 153
 154     return CURLE_OUT_OF_MEMORY;
 155   }
 156
 157   if(userp && *userp) {
 158     /* Populate our identity structure */
 159     result = Curl_create_sspi_identity(userp, passwdp, &identity);
 160     if(result) {
 161       free(spn);
 162       free(output_token);
 163       free(input_token);
 164
 165       return result;
 166     }
 167
 168     /* Allow proper cleanup of the identity structure */
 169     p_identity = &identity;
 170   }
 171   else
 172     /* Use the current Windows user */
 173     p_identity = NULL;
 174
 175   /* Acquire our credentials handle */
 176   status = s_pSecFn->AcquireCredentialsHandle(NULL,
 177                                               (TCHAR *) TEXT(SP_NAME_DIGEST),
 178                                               SECPKG_CRED_OUTBOUND, NULL,
 179                                               p_identity, NULL, NULL,
 180                                               &credentials, &expiry);
 181
 182   if(status != SEC_E_OK) {
 183     Curl_sspi_free_identity(p_identity);
 184     free(spn);
 185     free(output_token);
 186     free(input_token);
 187
 188     return CURLE_LOGIN_DENIED;
 189   }
 190
 191   /* Setup the challenge "input" security buffer */
 192   chlg_desc.ulVersion = SECBUFFER_VERSION;
 193   chlg_desc.cBuffers  = 1;
 194   chlg_desc.pBuffers  = &chlg_buf;
 195   chlg_buf.BufferType = SECBUFFER_TOKEN;
 196   chlg_buf.pvBuffer   = input_token;
 197   chlg_buf.cbBuffer   = curlx_uztoul(chlglen);
 198
 199   /* Setup the response "output" security buffer */
 200   resp_desc.ulVersion = SECBUFFER_VERSION;
 201   resp_desc.cBuffers  = 1;
 202   resp_desc.pBuffers  = &resp_buf;
 203   resp_buf.BufferType = SECBUFFER_TOKEN;
 204   resp_buf.pvBuffer   = output_token;
 205   resp_buf.cbBuffer   = curlx_uztoul(token_max);
 206
 207   /* Generate our response message */
 208   status = s_pSecFn->InitializeSecurityContext(&credentials, NULL, spn,
 209                                                0, 0, 0, &chlg_desc, 0,
 210                                                &context, &resp_desc, &attrs,
 211                                                &expiry);
 212
 213   if(status == SEC_I_COMPLETE_NEEDED ||
 214      status == SEC_I_COMPLETE_AND_CONTINUE)
 215     s_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
 216   else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
 217     s_pSecFn->FreeCredentialsHandle(&credentials);
 218     Curl_sspi_free_identity(p_identity);
 219     free(spn);
 220     free(output_token);
 221     free(input_token);
 222
 223     return CURLE_RECV_ERROR;
 224   }
 225
 226   /* Base64 encode the response */
 227   result = Curl_base64_encode(data, (char *) output_token, resp_buf.cbBuffer,
 228                               outptr, outlen);
 229
 230   /* Free our handles */
 231   s_pSecFn->DeleteSecurityContext(&context);
 232   s_pSecFn->FreeCredentialsHandle(&credentials);
 233
 234   /* Free the identity structure */
 235   Curl_sspi_free_identity(p_identity);
 236
 237   /* Free the SPN */
 238   free(spn);
 239
 240   /* Free the response buffer */
 241   free(output_token);
 242
 243   /* Free the decoded challenge message */
 244   free(input_token);
 245
 246   return result;
 247 }
 248
 249 /*
 250  * Curl_override_sspi_http_realm()
 251  *
 252  * This is used to populate the domain in a SSPI identity structure
 253  * The realm is extracted from the challenge message and used as the
 254  * domain if it is not already explicitly set.
 255  *
 256  * Parameters:
 257  *
 258  * chlg     [in]     - The challenge message.
 259  * identity [in/out] - The identity structure.
 260  *
 261  * Returns CURLE_OK on success.
 262  */
 263 CURLcode Curl_override_sspi_http_realm(const char *chlg,
 264                                        SEC_WINNT_AUTH_IDENTITY *identity)
 265 {
 266   xcharp_u domain, dup_domain;
 267
 268   /* If domain is blank or unset, check challenge message for realm */
 269   if(!identity->Domain || !identity->DomainLength) {
 270     for(;;) {
 271       char value[DIGEST_MAX_VALUE_LENGTH];
 272       char content[DIGEST_MAX_CONTENT_LENGTH];
 273
 274       /* Pass all additional spaces here */
 275       while(*chlg && ISSPACE(*chlg))
 276         chlg++;
 277
 278       /* Extract a value=content pair */
 279       if(Curl_auth_digest_get_pair(chlg, value, content, &chlg)) {
 280         if(strcasecompare(value, "realm")) {
 281
 282           /* Setup identity's domain and length */
 283           domain.tchar_ptr = Curl_convert_UTF8_to_tchar((char *) content);
 284           if(!domain.tchar_ptr)
 285             return CURLE_OUT_OF_MEMORY;
 286
 287           dup_domain.tchar_ptr = _tcsdup(domain.tchar_ptr);
 288           if(!dup_domain.tchar_ptr) {
 289             Curl_unicodefree(domain.tchar_ptr);
 290             return CURLE_OUT_OF_MEMORY;
 291           }
 292
 293           free(identity->Domain);
 294           identity->Domain = dup_domain.tbyte_ptr;
 295           identity->DomainLength = curlx_uztoul(_tcslen(dup_domain.tchar_ptr));
 296           dup_domain.tchar_ptr = NULL;
 297
 298           Curl_unicodefree(domain.tchar_ptr);
 299         }
 300         else {
 301           /* Unknown specifier, ignore it! */
 302         }
 303       }
 304       else
 305         break; /* We're done here */
 306
 307       /* Pass all additional spaces here */
 308       while(*chlg && ISSPACE(*chlg))
 309         chlg++;
 310
 311       /* Allow the list to be comma-separated */
 312       if(',' == *chlg)
 313         chlg++;
 314     }
 315   }
 316
 317   return CURLE_OK;
 318 }
 319
 320 /*
 321  * Curl_auth_decode_digest_http_message()
 322  *
 323  * This is used to decode a HTTP DIGEST challenge message into the seperate
 324  * attributes.
 325  *
 326  * Parameters:
 327  *
 328  * chlg    [in]     - The challenge message.
 329  * digest  [in/out] - The digest data struct being used and modified.
 330  *
 331  * Returns CURLE_OK on success.
 332  */
 333 CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
 334                                               struct digestdata *digest)
 335 {
 336   size_t chlglen = strlen(chlg);
 337
 338   /* We had an input token before so if there's another one now that means we
 339      provided bad credentials in the previous request or it's stale. */
 340   if(digest->input_token) {
 341     bool stale = false;
 342     const char *p = chlg;
 343
 344     /* Check for the 'stale' directive */
 345     for(;;) {
 346       char value[DIGEST_MAX_VALUE_LENGTH];
 347       char content[DIGEST_MAX_CONTENT_LENGTH];
 348
 349       while(*p && ISSPACE(*p))
 350         p++;
 351
 352       if(!Curl_auth_digest_get_pair(p, value, content, &p))
 353         break;
 354
 355       if(Curl_strcasecompare(value, "stale")
 356          && Curl_strcasecompare(content, "true")) {
 357         stale = true;
 358         break;
 359       }
 360
 361       while(*p && ISSPACE(*p))
 362         p++;
 363
 364       if(',' == *p)
 365         p++;
 366     }
 367
 368     if(stale)
 369       Curl_auth_digest_cleanup(digest);
 370     else
 371       return CURLE_LOGIN_DENIED;
 372   }
 373
 374   /* Store the challenge for use later */
 375   digest->input_token = (BYTE *) Curl_memdup(chlg, chlglen + 1);
 376   if(!digest->input_token)
 377     return CURLE_OUT_OF_MEMORY;
 378
 379   digest->input_token_len = chlglen;
 380
 381   return CURLE_OK;
 382 }
 383
 384 /*
 385  * Curl_auth_create_digest_http_message()
 386  *
 387  * This is used to generate a HTTP DIGEST response message ready for sending
 388  * to the recipient.
 389  *
 390  * Parameters:
 391  *
 392  * data    [in]     - The session handle.
 393  * userp   [in]     - The user name in the format User or Domain\User.
 394  * passdwp [in]     - The user's password.
 395  * request [in]     - The HTTP request.
 396  * uripath [in]     - The path of the HTTP uri.
 397  * digest  [in/out] - The digest data struct being used and modified.
 398  * outptr  [in/out] - The address where a pointer to newly allocated memory
 399  *                    holding the result will be stored upon completion.
 400  * outlen  [out]    - The length of the output message.
 401  *
 402  * Returns CURLE_OK on success.
 403  */
 404 CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
 405                                               const char *userp,
 406                                               const char *passwdp,
 407                                               const unsigned char *request,
 408                                               const unsigned char *uripath,
 409                                               struct digestdata *digest,
 410                                               char **outptr, size_t *outlen)
 411 {
 412   size_t token_max;
 413   char *resp;
 414   BYTE *output_token;
 415   size_t output_token_len;
 416   PSecPkgInfo SecurityPackage;
 417   SecBuffer chlg_buf[5];
 418   SecBufferDesc chlg_desc;
 419   SECURITY_STATUS status;
 420
 421   (void) data;
 422
 423   /* Query the security package for DigestSSP */
 424   status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
 425                                               &SecurityPackage);
 426   if(status != SEC_E_OK)
 427     return CURLE_NOT_BUILT_IN;
 428
 429   token_max = SecurityPackage->cbMaxToken;
 430
 431   /* Release the package buffer as it is not required anymore */
 432   s_pSecFn->FreeContextBuffer(SecurityPackage);
 433
 434   /* Allocate the output buffer according to the max token size as indicated
 435      by the security package */
 436   output_token = malloc(token_max);
 437   if(!output_token) {
 438     return CURLE_OUT_OF_MEMORY;
 439   }
 440
 441   if(digest->http_context) {
 442     chlg_desc.ulVersion    = SECBUFFER_VERSION;
 443     chlg_desc.cBuffers     = 5;
 444     chlg_desc.pBuffers     = chlg_buf;
 445     chlg_buf[0].BufferType = SECBUFFER_TOKEN;
 446     chlg_buf[0].pvBuffer   = NULL;
 447     chlg_buf[0].cbBuffer   = 0;
 448     chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
 449     chlg_buf[1].pvBuffer   = (void *) request;
 450     chlg_buf[1].cbBuffer   = curlx_uztoul(strlen((const char *) request));
 451     chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
 452     chlg_buf[2].pvBuffer   = (void *) uripath;
 453     chlg_buf[2].cbBuffer   = curlx_uztoul(strlen((const char *) uripath));
 454     chlg_buf[3].BufferType = SECBUFFER_PKG_PARAMS;
 455     chlg_buf[3].pvBuffer   = NULL;
 456     chlg_buf[3].cbBuffer   = 0;
 457     chlg_buf[4].BufferType = SECBUFFER_PADDING;
 458     chlg_buf[4].pvBuffer   = output_token;
 459     chlg_buf[4].cbBuffer   = curlx_uztoul(token_max);
 460
 461     status = s_pSecFn->MakeSignature(digest->http_context, 0, &chlg_desc, 0);
 462     if(status == SEC_E_OK)
 463       output_token_len = chlg_buf[4].cbBuffer;
 464     else { /* delete the context so a new one can be made */
 465       infof(data, "digest_sspi: MakeSignature failed, error 0x%08lx\n",
 466             (long)status);
 467       s_pSecFn->DeleteSecurityContext(digest->http_context);
 468       Curl_safefree(digest->http_context);
 469     }
 470   }
 471
 472   if(!digest->http_context) {
 473     CredHandle credentials;
 474     SEC_WINNT_AUTH_IDENTITY identity;
 475     SEC_WINNT_AUTH_IDENTITY *p_identity;
 476     SecBuffer resp_buf;
 477     SecBufferDesc resp_desc;
 478     unsigned long attrs;
 479     TimeStamp expiry; /* For Windows 9x compatibility of SSPI calls */
 480     TCHAR *spn;
 481
 482     if(userp && *userp) {
 483       /* Populate our identity structure */
 484       if(Curl_create_sspi_identity(userp, passwdp, &identity)) {
 485         free(output_token);
 486         return CURLE_OUT_OF_MEMORY;
 487       }
 488
 489       /* Populate our identity domain */
 490       if(Curl_override_sspi_http_realm((const char *) digest->input_token,
 491                                        &identity)) {
 492         free(output_token);
 493         return CURLE_OUT_OF_MEMORY;
 494       }
 495
 496       /* Allow proper cleanup of the identity structure */
 497       p_identity = &identity;
 498     }
 499     else
 500       /* Use the current Windows user */
 501       p_identity = NULL;
 502
 503     /* Acquire our credentials handle */
 504     status = s_pSecFn->AcquireCredentialsHandle(NULL,
 505                                                 (TCHAR *) TEXT(SP_NAME_DIGEST),
 506                                                 SECPKG_CRED_OUTBOUND, NULL,
 507                                                 p_identity, NULL, NULL,
 508                                                 &credentials, &expiry);
 509     if(status != SEC_E_OK) {
 510       Curl_sspi_free_identity(p_identity);
 511       free(output_token);
 512
 513       return CURLE_LOGIN_DENIED;
 514     }
 515
 516     /* Setup the challenge "input" security buffer if present */
 517     chlg_desc.ulVersion    = SECBUFFER_VERSION;
 518     chlg_desc.cBuffers     = 3;
 519     chlg_desc.pBuffers     = chlg_buf;
 520     chlg_buf[0].BufferType = SECBUFFER_TOKEN;
 521     chlg_buf[0].pvBuffer   = digest->input_token;
 522     chlg_buf[0].cbBuffer   = curlx_uztoul(digest->input_token_len);
 523     chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
 524     chlg_buf[1].pvBuffer   = (void *) request;
 525     chlg_buf[1].cbBuffer   = curlx_uztoul(strlen((const char *) request));
 526     chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
 527     chlg_buf[2].pvBuffer   = NULL;
 528     chlg_buf[2].cbBuffer   = 0;
 529
 530     /* Setup the response "output" security buffer */
 531     resp_desc.ulVersion = SECBUFFER_VERSION;
 532     resp_desc.cBuffers  = 1;
 533     resp_desc.pBuffers  = &resp_buf;
 534     resp_buf.BufferType = SECBUFFER_TOKEN;
 535     resp_buf.pvBuffer   = output_token;
 536     resp_buf.cbBuffer   = curlx_uztoul(token_max);
 537
 538     spn = Curl_convert_UTF8_to_tchar((char *) uripath);
 539     if(!spn) {
 540       s_pSecFn->FreeCredentialsHandle(&credentials);
 541
 542       Curl_sspi_free_identity(p_identity);
 543       free(output_token);
 544
 545       return CURLE_OUT_OF_MEMORY;
 546     }
 547
 548     /* Allocate our new context handle */
 549     digest->http_context = calloc(1, sizeof(CtxtHandle));
 550     if(!digest->http_context)
 551       return CURLE_OUT_OF_MEMORY;
 552
 553     /* Generate our reponse message */
 554     status = s_pSecFn->InitializeSecurityContext(&credentials, NULL,
 555                                                  spn,
 556                                                  ISC_REQ_USE_HTTP_STYLE, 0, 0,
 557                                                  &chlg_desc, 0,
 558                                                  digest->http_context,
 559                                                  &resp_desc, &attrs, &expiry);
 560     Curl_unicodefree(spn);
 561
 562     if(status == SEC_I_COMPLETE_NEEDED ||
 563        status == SEC_I_COMPLETE_AND_CONTINUE)
 564       s_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
 565     else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
 566       s_pSecFn->FreeCredentialsHandle(&credentials);
 567
 568       Curl_sspi_free_identity(p_identity);
 569       free(output_token);
 570
 571       Curl_safefree(digest->http_context);
 572
 573       return CURLE_OUT_OF_MEMORY;
 574     }
 575
 576     output_token_len = resp_buf.cbBuffer;
 577
 578     s_pSecFn->FreeCredentialsHandle(&credentials);
 579     Curl_sspi_free_identity(p_identity);
 580   }
 581
 582   resp = malloc(output_token_len + 1);
 583   if(!resp) {
 584     free(output_token);
 585
 586     return CURLE_OUT_OF_MEMORY;
 587   }
 588
 589   /* Copy the generated reponse */
 590   memcpy(resp, output_token, output_token_len);
 591   resp[output_token_len] = 0;
 592
 593   /* Return the response */
 594   *outptr = resp;
 595   *outlen = output_token_len;
 596
 597   /* Free the response buffer */
 598   free(output_token);
 599
 600   return CURLE_OK;
 601 }
 602
 603 /*
 604  * Curl_auth_digest_cleanup()
 605  *
 606  * This is used to clean up the digest specific data.
 607  *
 608  * Parameters:
 609  *
 610  * digest    [in/out] - The digest data struct being cleaned up.
 611  *
 612  */
 613 void Curl_auth_digest_cleanup(struct digestdata *digest)
 614 {
 615   /* Free the input token */
 616   Curl_safefree(digest->input_token);
 617
 618   /* Reset any variables */
 619   digest->input_token_len = 0;
 620
 621   /* Delete security context */
 622   if(digest->http_context) {
 623     s_pSecFn->DeleteSecurityContext(digest->http_context);
 624     Curl_safefree(digest->http_context);
 625   }
 626 }
 627
 628 #endif /* USE_WINDOWS_SSPI && !CURL_DISABLE_CRYPTO_AUTH */