mirror of
https://github.com/curl/curl.git
synced 2026-06-23 09:55:38 +03:00
193cb00ce9
Before this patch curl used the C preprocessor to override standard memory allocation symbols: malloc, calloc, strdup, realloc, free. The goal of these is to replace them with curl's debug wrappers in `CURLDEBUG` builds, another was to replace them with the wrappers calling user-defined allocators in libcurl. This solution needed a bunch of workarounds to avoid breaking external headers: it relied on include order to do the overriding last. For "unity" builds it needed to reset overrides before external includes. Also in test apps, which are always built as single source files. It also needed the `(symbol)` trick to avoid overrides in some places. This would still not fix cases where the standard symbols were macros. It was also fragile and difficult to figure out which was the actual function behind an alloc or free call in a specific piece of code. This in turn caused bugs where the wrong allocator was accidentally called. To avoid these problems, this patch replaces this solution with `curlx_`-prefixed allocator macros, and mapping them _once_ to either the libcurl wrappers, the debug wrappers or the standard ones, matching the rest of the code in libtests. This concludes the long journey to avoid redefining standard functions in the curl codebase. Note: I did not update `packages/OS400/*.c` sources. They did not `#include` `curl_setup.h`, `curl_memory.h` or `memdebug.h`, meaning the overrides were never applied to them. This may or may not have been correct. For now I suppressed the direct use of standard allocators via a local `.checksrc`. Probably they (except for `curlcl.c`) should be updated to include `curl_setup.h` and use the `curlx_` macros. This patch changes mappings in two places: - `lib/curl_threads.c` in libtests: Before this patch it mapped to libcurl allocators. After, it maps to standard allocators, like the rest of libtests code. - `units`: before this patch it mapped to standard allocators. After, it maps to libcurl allocators. Also: - drop all position-dependent `curl_memory.h` and `memdebug.h` includes, and delete the now unnecessary headers. - rename `Curl_tcsdup` macro to `curlx_tcsdup` and define like the other allocators. - map `curlx_strdup()` to `_strdup()` on Windows (was: `strdup()`). To fix warnings silenced via `_CRT_NONSTDC_NO_DEPRECATE`. - multibyte: map `curlx_convert_*()` to `_strdup()` on Windows (was: `strdup()`). - src: do not reuse the `strdup` name for the local replacement. - lib509: call `_strdup()` on Windows (was: `strdup()`). - test1132: delete test obsoleted by this patch. - CHECKSRC.md: update text for `SNPRINTF`. - checksrc: ban standard allocator symbols. Follow-up tob12da22db1#18866 Follow-up todb98daab05#18844 Follow-up to4deea9396b#18814 Follow-up to9678ff5b1b#18776 Follow-up to10bac43b87#18774 Follow-up to20142f5d06#18634 Follow-up tobf7375ecc5#18503 Follow-up to9863599d69#18502 Follow-up to3bb5e58c10#17827 Closes #19626
671 lines
21 KiB
C
671 lines
21 KiB
C
/***************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) Steve Holme, <steve_holme@hotmail.com>.
|
|
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
|
|
*
|
|
* This software is licensed as described in the file COPYING, which
|
|
* you should have received as part of this distribution. The terms
|
|
* are also available at https://curl.se/docs/copyright.html.
|
|
*
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
* copies of the Software, and permit persons to whom the Software is
|
|
* furnished to do so, under the terms of the COPYING file.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
* SPDX-License-Identifier: curl
|
|
*
|
|
* RFC2831 DIGEST-MD5 authentication
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "../curl_setup.h"
|
|
|
|
#if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_DIGEST_AUTH)
|
|
|
|
#include <curl/curl.h>
|
|
|
|
#include "vauth.h"
|
|
#include "digest.h"
|
|
#include "../urldata.h"
|
|
#include "../curlx/warnless.h"
|
|
#include "../curlx/multibyte.h"
|
|
#include "../sendf.h"
|
|
#include "../strdup.h"
|
|
#include "../strcase.h"
|
|
#include "../strerror.h"
|
|
|
|
/*
|
|
* Curl_auth_is_digest_supported()
|
|
*
|
|
* This is used to evaluate if DIGEST is supported.
|
|
*
|
|
* Parameters: None
|
|
*
|
|
* Returns TRUE if DIGEST is supported by Windows SSPI.
|
|
*/
|
|
bool Curl_auth_is_digest_supported(void)
|
|
{
|
|
PSecPkgInfo SecurityPackage;
|
|
SECURITY_STATUS status;
|
|
|
|
/* Query the security package for Digest */
|
|
status =
|
|
Curl_pSecFn->QuerySecurityPackageInfo(
|
|
(TCHAR *)CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
|
|
&SecurityPackage);
|
|
|
|
/* Release the package buffer as it is not required anymore */
|
|
if(status == SEC_E_OK) {
|
|
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
|
|
}
|
|
|
|
return status == SEC_E_OK;
|
|
}
|
|
|
|
/*
|
|
* Curl_auth_create_digest_md5_message()
|
|
*
|
|
* This is used to generate an already encoded DIGEST-MD5 response message
|
|
* ready for sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* chlg [in] - The challenge message.
|
|
* userp [in] - The username in the format User or Domain\User.
|
|
* passwdp [in] - The user's password.
|
|
* service [in] - The service type such as http, smtp, pop or imap.
|
|
* out [out] - The result storage.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_auth_create_digest_md5_message(struct Curl_easy *data,
|
|
const struct bufref *chlg,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
const char *service,
|
|
struct bufref *out)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
TCHAR *spn = NULL;
|
|
size_t token_max = 0;
|
|
unsigned char *output_token = NULL;
|
|
CredHandle credentials;
|
|
CtxtHandle context;
|
|
PSecPkgInfo SecurityPackage;
|
|
SEC_WINNT_AUTH_IDENTITY identity;
|
|
SEC_WINNT_AUTH_IDENTITY *p_identity;
|
|
SecBuffer chlg_buf;
|
|
SecBuffer resp_buf;
|
|
SecBufferDesc chlg_desc;
|
|
SecBufferDesc resp_desc;
|
|
SECURITY_STATUS status;
|
|
unsigned long attrs;
|
|
|
|
/* Ensure we have a valid challenge message */
|
|
if(!Curl_bufref_len(chlg)) {
|
|
infof(data, "DIGEST-MD5 handshake failure (empty challenge message)");
|
|
return CURLE_BAD_CONTENT_ENCODING;
|
|
}
|
|
|
|
/* Query the security package for DigestSSP */
|
|
status =
|
|
Curl_pSecFn->QuerySecurityPackageInfo(
|
|
(TCHAR *)CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
|
|
&SecurityPackage);
|
|
if(status != SEC_E_OK) {
|
|
failf(data, "SSPI: could not get auth info");
|
|
return CURLE_AUTH_ERROR;
|
|
}
|
|
|
|
token_max = SecurityPackage->cbMaxToken;
|
|
|
|
/* Release the package buffer as it is not required anymore */
|
|
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
|
|
|
|
/* Allocate our response buffer */
|
|
output_token = curlx_malloc(token_max);
|
|
if(!output_token)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
/* Generate our SPN */
|
|
spn = Curl_auth_build_spn(service, data->conn->host.name, NULL);
|
|
if(!spn) {
|
|
curlx_free(output_token);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if(userp && *userp) {
|
|
/* Populate our identity structure */
|
|
result = Curl_create_sspi_identity(userp, passwdp, &identity);
|
|
if(result) {
|
|
curlx_free(spn);
|
|
curlx_free(output_token);
|
|
return result;
|
|
}
|
|
|
|
/* Allow proper cleanup of the identity structure */
|
|
p_identity = &identity;
|
|
}
|
|
else
|
|
/* Use the current Windows user */
|
|
p_identity = NULL;
|
|
|
|
/* Acquire our credentials handle */
|
|
status = Curl_pSecFn->AcquireCredentialsHandle(NULL,
|
|
(TCHAR *)CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
|
|
SECPKG_CRED_OUTBOUND, NULL,
|
|
p_identity, NULL, NULL,
|
|
&credentials, NULL);
|
|
|
|
if(status != SEC_E_OK) {
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(spn);
|
|
curlx_free(output_token);
|
|
return CURLE_LOGIN_DENIED;
|
|
}
|
|
|
|
/* Setup the challenge "input" security buffer */
|
|
chlg_desc.ulVersion = SECBUFFER_VERSION;
|
|
chlg_desc.cBuffers = 1;
|
|
chlg_desc.pBuffers = &chlg_buf;
|
|
chlg_buf.BufferType = SECBUFFER_TOKEN;
|
|
chlg_buf.pvBuffer = CURL_UNCONST(Curl_bufref_ptr(chlg));
|
|
chlg_buf.cbBuffer = curlx_uztoul(Curl_bufref_len(chlg));
|
|
|
|
/* Setup the response "output" security buffer */
|
|
resp_desc.ulVersion = SECBUFFER_VERSION;
|
|
resp_desc.cBuffers = 1;
|
|
resp_desc.pBuffers = &resp_buf;
|
|
resp_buf.BufferType = SECBUFFER_TOKEN;
|
|
resp_buf.pvBuffer = output_token;
|
|
resp_buf.cbBuffer = curlx_uztoul(token_max);
|
|
|
|
/* Generate our response message */
|
|
status = Curl_pSecFn->InitializeSecurityContext(&credentials, NULL, spn,
|
|
0, 0, 0, &chlg_desc, 0,
|
|
&context, &resp_desc, &attrs,
|
|
NULL);
|
|
|
|
if(status == SEC_I_COMPLETE_NEEDED ||
|
|
status == SEC_I_COMPLETE_AND_CONTINUE)
|
|
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
|
|
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
|
|
#ifndef CURL_DISABLE_VERBOSE_STRINGS
|
|
char buffer[STRERROR_LEN];
|
|
#endif
|
|
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(spn);
|
|
curlx_free(output_token);
|
|
|
|
if(status == SEC_E_INSUFFICIENT_MEMORY)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
#ifndef CURL_DISABLE_VERBOSE_STRINGS
|
|
infof(data, "schannel: InitializeSecurityContext failed: %s",
|
|
Curl_sspi_strerror(status, buffer, sizeof(buffer)));
|
|
#endif
|
|
|
|
return CURLE_AUTH_ERROR;
|
|
}
|
|
|
|
/* Return the response. */
|
|
Curl_bufref_set(out, output_token, resp_buf.cbBuffer, curl_free);
|
|
|
|
/* Free our handles */
|
|
Curl_pSecFn->DeleteSecurityContext(&context);
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
|
|
/* Free the identity structure */
|
|
Curl_sspi_free_identity(p_identity);
|
|
|
|
/* Free the SPN */
|
|
curlx_free(spn);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Curl_override_sspi_http_realm()
|
|
*
|
|
* This is used to populate the domain in an SSPI identity structure
|
|
* The realm is extracted from the challenge message and used as the
|
|
* domain if it is not already explicitly set.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* chlg [in] - The challenge message.
|
|
* identity [in/out] - The identity structure.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_override_sspi_http_realm(const char *chlg,
|
|
SEC_WINNT_AUTH_IDENTITY *identity)
|
|
{
|
|
xcharp_u domain, dup_domain;
|
|
|
|
/* If domain is blank or unset, check challenge message for realm */
|
|
if(!identity->Domain || !identity->DomainLength) {
|
|
for(;;) {
|
|
char value[DIGEST_MAX_VALUE_LENGTH];
|
|
char content[DIGEST_MAX_CONTENT_LENGTH];
|
|
|
|
/* Pass all additional spaces here */
|
|
while(*chlg && ISBLANK(*chlg))
|
|
chlg++;
|
|
|
|
/* Extract a value=content pair */
|
|
if(Curl_auth_digest_get_pair(chlg, value, content, &chlg)) {
|
|
if(curl_strequal(value, "realm")) {
|
|
|
|
/* Setup identity's domain and length */
|
|
domain.tchar_ptr = curlx_convert_UTF8_to_tchar(content);
|
|
if(!domain.tchar_ptr)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
dup_domain.tchar_ptr = curlx_tcsdup(domain.tchar_ptr);
|
|
if(!dup_domain.tchar_ptr) {
|
|
curlx_unicodefree(domain.tchar_ptr);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
curlx_free(identity->Domain);
|
|
identity->Domain = dup_domain.tbyte_ptr;
|
|
identity->DomainLength = curlx_uztoul(_tcslen(dup_domain.tchar_ptr));
|
|
dup_domain.tchar_ptr = NULL;
|
|
|
|
curlx_unicodefree(domain.tchar_ptr);
|
|
}
|
|
else {
|
|
/* Unknown specifier, ignore it! */
|
|
}
|
|
}
|
|
else
|
|
break; /* We are done here */
|
|
|
|
/* Pass all additional spaces here */
|
|
while(*chlg && ISBLANK(*chlg))
|
|
chlg++;
|
|
|
|
/* Allow the list to be comma-separated */
|
|
if(',' == *chlg)
|
|
chlg++;
|
|
}
|
|
}
|
|
|
|
return CURLE_OK;
|
|
}
|
|
|
|
/*
|
|
* Curl_auth_decode_digest_http_message()
|
|
*
|
|
* This is used to decode an HTTP DIGEST challenge message into the separate
|
|
* attributes.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* chlg [in] - The challenge message.
|
|
* digest [in/out] - The digest data struct being used and modified.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
|
|
struct digestdata *digest)
|
|
{
|
|
size_t chlglen = strlen(chlg);
|
|
|
|
/* We had an input token before so if there is another one now that means we
|
|
provided bad credentials in the previous request or it is stale. */
|
|
if(digest->input_token) {
|
|
bool stale = FALSE;
|
|
const char *p = chlg;
|
|
|
|
/* Check for the 'stale' directive */
|
|
for(;;) {
|
|
char value[DIGEST_MAX_VALUE_LENGTH];
|
|
char content[DIGEST_MAX_CONTENT_LENGTH];
|
|
|
|
while(*p && ISBLANK(*p))
|
|
p++;
|
|
|
|
if(!Curl_auth_digest_get_pair(p, value, content, &p))
|
|
break;
|
|
|
|
if(curl_strequal(value, "stale") &&
|
|
curl_strequal(content, "true")) {
|
|
stale = TRUE;
|
|
break;
|
|
}
|
|
|
|
while(*p && ISBLANK(*p))
|
|
p++;
|
|
|
|
if(',' == *p)
|
|
p++;
|
|
}
|
|
|
|
if(stale)
|
|
Curl_auth_digest_cleanup(digest);
|
|
else
|
|
return CURLE_LOGIN_DENIED;
|
|
}
|
|
|
|
/* Store the challenge for use later */
|
|
digest->input_token = (BYTE *)Curl_memdup(chlg, chlglen + 1);
|
|
if(!digest->input_token)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
digest->input_token_len = chlglen;
|
|
|
|
return CURLE_OK;
|
|
}
|
|
|
|
/*
|
|
* Curl_auth_create_digest_http_message()
|
|
*
|
|
* This is used to generate an HTTP DIGEST response message ready for sending
|
|
* to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* userp [in] - The username in the format User or Domain\User.
|
|
* passwdp [in] - The user's password.
|
|
* request [in] - The HTTP request.
|
|
* uripath [in] - The path of the HTTP uri.
|
|
* digest [in/out] - The digest data struct being used and modified.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
const unsigned char *request,
|
|
const unsigned char *uripath,
|
|
struct digestdata *digest,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
size_t token_max;
|
|
char *resp;
|
|
BYTE *output_token;
|
|
size_t output_token_len = 0;
|
|
PSecPkgInfo SecurityPackage;
|
|
SecBuffer chlg_buf[5];
|
|
SecBufferDesc chlg_desc;
|
|
SECURITY_STATUS status;
|
|
|
|
(void)data;
|
|
|
|
/* Query the security package for DigestSSP */
|
|
status =
|
|
Curl_pSecFn->QuerySecurityPackageInfo(
|
|
(TCHAR *)CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
|
|
&SecurityPackage);
|
|
if(status != SEC_E_OK) {
|
|
failf(data, "SSPI: could not get auth info");
|
|
return CURLE_AUTH_ERROR;
|
|
}
|
|
|
|
token_max = SecurityPackage->cbMaxToken;
|
|
|
|
/* Release the package buffer as it is not required anymore */
|
|
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
|
|
|
|
/* Allocate the output buffer according to the max token size as indicated
|
|
by the security package */
|
|
output_token = curlx_malloc(token_max);
|
|
if(!output_token) {
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* If the user/passwd that was used to make the identity for http_context
|
|
has changed then delete that context. */
|
|
if((userp && !digest->user) || (!userp && digest->user) ||
|
|
(passwdp && !digest->passwd) || (!passwdp && digest->passwd) ||
|
|
(userp && digest->user && Curl_timestrcmp(userp, digest->user)) ||
|
|
(passwdp && digest->passwd && Curl_timestrcmp(passwdp, digest->passwd))) {
|
|
if(digest->http_context) {
|
|
Curl_pSecFn->DeleteSecurityContext(digest->http_context);
|
|
Curl_safefree(digest->http_context);
|
|
}
|
|
Curl_safefree(digest->user);
|
|
Curl_safefree(digest->passwd);
|
|
}
|
|
|
|
if(digest->http_context) {
|
|
chlg_desc.ulVersion = SECBUFFER_VERSION;
|
|
chlg_desc.cBuffers = 5;
|
|
chlg_desc.pBuffers = chlg_buf;
|
|
chlg_buf[0].BufferType = SECBUFFER_TOKEN;
|
|
chlg_buf[0].pvBuffer = NULL;
|
|
chlg_buf[0].cbBuffer = 0;
|
|
chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
|
|
chlg_buf[1].pvBuffer = CURL_UNCONST(request);
|
|
chlg_buf[1].cbBuffer = curlx_uztoul(strlen((const char *) request));
|
|
chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
|
|
chlg_buf[2].pvBuffer = CURL_UNCONST(uripath);
|
|
chlg_buf[2].cbBuffer = curlx_uztoul(strlen((const char *) uripath));
|
|
chlg_buf[3].BufferType = SECBUFFER_PKG_PARAMS;
|
|
chlg_buf[3].pvBuffer = NULL;
|
|
chlg_buf[3].cbBuffer = 0;
|
|
chlg_buf[4].BufferType = SECBUFFER_PADDING;
|
|
chlg_buf[4].pvBuffer = output_token;
|
|
chlg_buf[4].cbBuffer = curlx_uztoul(token_max);
|
|
|
|
status = Curl_pSecFn->MakeSignature(digest->http_context, 0, &chlg_desc,
|
|
0);
|
|
if(status == SEC_E_OK)
|
|
output_token_len = chlg_buf[4].cbBuffer;
|
|
else { /* delete the context so a new one can be made */
|
|
infof(data, "digest_sspi: MakeSignature failed, error 0x%08lx", status);
|
|
Curl_pSecFn->DeleteSecurityContext(digest->http_context);
|
|
Curl_safefree(digest->http_context);
|
|
}
|
|
}
|
|
|
|
if(!digest->http_context) {
|
|
CredHandle credentials;
|
|
SEC_WINNT_AUTH_IDENTITY identity;
|
|
SEC_WINNT_AUTH_IDENTITY *p_identity;
|
|
SecBuffer resp_buf;
|
|
SecBufferDesc resp_desc;
|
|
unsigned long attrs;
|
|
TCHAR *spn;
|
|
|
|
/* free the copy of user/passwd used to make the previous identity */
|
|
Curl_safefree(digest->user);
|
|
Curl_safefree(digest->passwd);
|
|
|
|
if(userp && *userp) {
|
|
/* Populate our identity structure */
|
|
if(Curl_create_sspi_identity(userp, passwdp, &identity)) {
|
|
curlx_free(output_token);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Populate our identity domain */
|
|
if(Curl_override_sspi_http_realm((const char *) digest->input_token,
|
|
&identity)) {
|
|
Curl_sspi_free_identity(&identity);
|
|
curlx_free(output_token);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Allow proper cleanup of the identity structure */
|
|
p_identity = &identity;
|
|
}
|
|
else
|
|
/* Use the current Windows user */
|
|
p_identity = NULL;
|
|
|
|
if(userp) {
|
|
digest->user = curlx_strdup(userp);
|
|
|
|
if(!digest->user) {
|
|
curlx_free(output_token);
|
|
Curl_sspi_free_identity(p_identity);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
if(passwdp) {
|
|
digest->passwd = curlx_strdup(passwdp);
|
|
|
|
if(!digest->passwd) {
|
|
curlx_free(output_token);
|
|
Curl_sspi_free_identity(p_identity);
|
|
Curl_safefree(digest->user);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
/* Acquire our credentials handle */
|
|
status = Curl_pSecFn->AcquireCredentialsHandle(NULL,
|
|
(TCHAR *)CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
|
|
SECPKG_CRED_OUTBOUND, NULL,
|
|
p_identity, NULL, NULL,
|
|
&credentials, NULL);
|
|
if(status != SEC_E_OK) {
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(output_token);
|
|
|
|
return CURLE_LOGIN_DENIED;
|
|
}
|
|
|
|
/* Setup the challenge "input" security buffer if present */
|
|
chlg_desc.ulVersion = SECBUFFER_VERSION;
|
|
chlg_desc.cBuffers = 3;
|
|
chlg_desc.pBuffers = chlg_buf;
|
|
chlg_buf[0].BufferType = SECBUFFER_TOKEN;
|
|
chlg_buf[0].pvBuffer = digest->input_token;
|
|
chlg_buf[0].cbBuffer = curlx_uztoul(digest->input_token_len);
|
|
chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
|
|
chlg_buf[1].pvBuffer = CURL_UNCONST(request);
|
|
chlg_buf[1].cbBuffer = curlx_uztoul(strlen((const char *) request));
|
|
chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
|
|
chlg_buf[2].pvBuffer = NULL;
|
|
chlg_buf[2].cbBuffer = 0;
|
|
|
|
/* Setup the response "output" security buffer */
|
|
resp_desc.ulVersion = SECBUFFER_VERSION;
|
|
resp_desc.cBuffers = 1;
|
|
resp_desc.pBuffers = &resp_buf;
|
|
resp_buf.BufferType = SECBUFFER_TOKEN;
|
|
resp_buf.pvBuffer = output_token;
|
|
resp_buf.cbBuffer = curlx_uztoul(token_max);
|
|
|
|
spn = curlx_convert_UTF8_to_tchar((const char *) uripath);
|
|
if(!spn) {
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(output_token);
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Allocate our new context handle */
|
|
digest->http_context = curlx_calloc(1, sizeof(CtxtHandle));
|
|
if(!digest->http_context) {
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
curlx_unicodefree(spn);
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(output_token);
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Generate our response message */
|
|
status = Curl_pSecFn->InitializeSecurityContext(&credentials, NULL,
|
|
spn,
|
|
ISC_REQ_USE_HTTP_STYLE, 0, 0,
|
|
&chlg_desc, 0,
|
|
digest->http_context,
|
|
&resp_desc, &attrs, NULL);
|
|
curlx_unicodefree(spn);
|
|
|
|
if(status == SEC_I_COMPLETE_NEEDED ||
|
|
status == SEC_I_COMPLETE_AND_CONTINUE)
|
|
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
|
|
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
|
|
#ifndef CURL_DISABLE_VERBOSE_STRINGS
|
|
char buffer[STRERROR_LEN];
|
|
#endif
|
|
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
|
|
Curl_sspi_free_identity(p_identity);
|
|
curlx_free(output_token);
|
|
|
|
Curl_safefree(digest->http_context);
|
|
|
|
if(status == SEC_E_INSUFFICIENT_MEMORY)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
#ifndef CURL_DISABLE_VERBOSE_STRINGS
|
|
infof(data, "schannel: InitializeSecurityContext failed: %s",
|
|
Curl_sspi_strerror(status, buffer, sizeof(buffer)));
|
|
#endif
|
|
|
|
return CURLE_AUTH_ERROR;
|
|
}
|
|
|
|
output_token_len = resp_buf.cbBuffer;
|
|
|
|
Curl_pSecFn->FreeCredentialsHandle(&credentials);
|
|
Curl_sspi_free_identity(p_identity);
|
|
}
|
|
|
|
resp = Curl_memdup0((const char *)output_token, output_token_len);
|
|
curlx_free(output_token);
|
|
if(!resp) {
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Return the response */
|
|
*outptr = resp;
|
|
*outlen = output_token_len;
|
|
return CURLE_OK;
|
|
}
|
|
|
|
/*
|
|
* Curl_auth_digest_cleanup()
|
|
*
|
|
* This is used to clean up the digest specific data.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* digest [in/out] - The digest data struct being cleaned up.
|
|
*
|
|
*/
|
|
void Curl_auth_digest_cleanup(struct digestdata *digest)
|
|
{
|
|
/* Free the input token */
|
|
Curl_safefree(digest->input_token);
|
|
|
|
/* Reset any variables */
|
|
digest->input_token_len = 0;
|
|
|
|
/* Delete security context */
|
|
if(digest->http_context) {
|
|
Curl_pSecFn->DeleteSecurityContext(digest->http_context);
|
|
Curl_safefree(digest->http_context);
|
|
}
|
|
|
|
/* Free the copy of user/passwd used to make the identity for http_context */
|
|
Curl_safefree(digest->user);
|
|
Curl_safefree(digest->passwd);
|
|
}
|
|
|
|
#endif /* USE_WINDOWS_SSPI && !CURL_DISABLE_DIGEST_AUTH */
|