28 #if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_CRYPTO_AUTH) 57 PSecPkgInfo SecurityPackage;
58 SECURITY_STATUS status;
61 status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
64 return (status == SEC_E_OK ?
TRUE :
FALSE);
91 char **outptr,
size_t *outlen)
97 unsigned char *input_token = NULL;
98 unsigned char *output_token = NULL;
99 CredHandle credentials;
101 PSecPkgInfo SecurityPackage;
102 SEC_WINNT_AUTH_IDENTITY identity;
103 SEC_WINNT_AUTH_IDENTITY *p_identity;
106 SecBufferDesc chlg_desc;
107 SecBufferDesc resp_desc;
108 SECURITY_STATUS status;
113 if(strlen(chlg64) && *chlg64 !=
'=') {
121 infof(data,
"DIGEST-MD5 handshake failure (empty challenge message)\n");
127 status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
129 if(status != SEC_E_OK) {
135 token_max = SecurityPackage->cbMaxToken;
138 s_pSecFn->FreeContextBuffer(SecurityPackage);
141 output_token =
malloc(token_max);
157 if(userp && *userp) {
159 result = Curl_create_sspi_identity(userp, passwdp, &identity);
169 p_identity = &identity;
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);
182 if(status != SEC_E_OK) {
183 Curl_sspi_free_identity(p_identity);
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;
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;
208 status = s_pSecFn->InitializeSecurityContext(&credentials, NULL, spn,
209 0, 0, 0, &chlg_desc, 0,
210 &context, &resp_desc, &attrs,
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);
231 s_pSecFn->DeleteSecurityContext(&context);
232 s_pSecFn->FreeCredentialsHandle(&credentials);
235 Curl_sspi_free_identity(p_identity);
263 CURLcode Curl_override_sspi_http_realm(
const char *chlg,
264 SEC_WINNT_AUTH_IDENTITY *identity)
266 xcharp_u domain, dup_domain;
269 if(!identity->Domain || !identity->DomainLength) {
283 domain.tchar_ptr = Curl_convert_UTF8_to_tchar((
char *) content);
284 if(!domain.tchar_ptr)
287 dup_domain.tchar_ptr = _tcsdup(domain.tchar_ptr);
288 if(!dup_domain.tchar_ptr) {
289 Curl_unicodefree(domain.tchar_ptr);
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;
298 Curl_unicodefree(domain.tchar_ptr);
336 size_t chlglen = strlen(chlg);
340 if(digest->input_token) {
342 const char *
p = chlg;
376 if(!digest->input_token)
379 digest->input_token_len = chlglen;
407 const unsigned char *request,
408 const unsigned char *uripath,
410 char **outptr,
size_t *outlen)
415 size_t output_token_len = 0;
416 PSecPkgInfo SecurityPackage;
417 SecBuffer chlg_buf[5];
418 SecBufferDesc chlg_desc;
419 SECURITY_STATUS status;
424 status = s_pSecFn->QuerySecurityPackageInfo((TCHAR *) TEXT(SP_NAME_DIGEST),
426 if(status != SEC_E_OK)
429 token_max = SecurityPackage->cbMaxToken;
432 s_pSecFn->FreeContextBuffer(SecurityPackage);
436 output_token =
malloc(token_max);
443 if((userp && !digest->user) || (!userp && digest->user) ||
444 (passwdp && !digest->passwd) || (!passwdp && digest->passwd) ||
445 (userp && digest->user && strcmp(userp, digest->user)) ||
446 (passwdp && digest->passwd && strcmp(passwdp, digest->passwd))) {
447 if(digest->http_context) {
448 s_pSecFn->DeleteSecurityContext(digest->http_context);
455 if(digest->http_context) {
456 chlg_desc.ulVersion = SECBUFFER_VERSION;
457 chlg_desc.cBuffers = 5;
458 chlg_desc.pBuffers = chlg_buf;
459 chlg_buf[0].BufferType = SECBUFFER_TOKEN;
460 chlg_buf[0].pvBuffer = NULL;
461 chlg_buf[0].cbBuffer = 0;
462 chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
463 chlg_buf[1].pvBuffer = (
void *) request;
464 chlg_buf[1].cbBuffer =
curlx_uztoul(strlen((
const char *) request));
465 chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
466 chlg_buf[2].pvBuffer = (
void *) uripath;
467 chlg_buf[2].cbBuffer =
curlx_uztoul(strlen((
const char *) uripath));
468 chlg_buf[3].BufferType = SECBUFFER_PKG_PARAMS;
469 chlg_buf[3].pvBuffer = NULL;
470 chlg_buf[3].cbBuffer = 0;
471 chlg_buf[4].BufferType = SECBUFFER_PADDING;
472 chlg_buf[4].pvBuffer = output_token;
475 status = s_pSecFn->MakeSignature(digest->http_context, 0, &chlg_desc, 0);
476 if(status == SEC_E_OK)
477 output_token_len = chlg_buf[4].cbBuffer;
479 infof(data,
"digest_sspi: MakeSignature failed, error 0x%08lx\n",
481 s_pSecFn->DeleteSecurityContext(digest->http_context);
486 if(!digest->http_context) {
487 CredHandle credentials;
488 SEC_WINNT_AUTH_IDENTITY identity;
489 SEC_WINNT_AUTH_IDENTITY *p_identity;
491 SecBufferDesc resp_desc;
500 if(userp && *userp) {
502 if(Curl_create_sspi_identity(userp, passwdp, &identity)) {
508 if(Curl_override_sspi_http_realm((
const char *) digest->input_token,
515 p_identity = &identity;
522 digest->user =
strdup(userp);
531 digest->passwd =
strdup(passwdp);
533 if(!digest->passwd) {
541 status = s_pSecFn->AcquireCredentialsHandle(NULL,
542 (TCHAR *) TEXT(SP_NAME_DIGEST),
543 SECPKG_CRED_OUTBOUND, NULL,
544 p_identity, NULL, NULL,
545 &credentials, &expiry);
546 if(status != SEC_E_OK) {
547 Curl_sspi_free_identity(p_identity);
554 chlg_desc.ulVersion = SECBUFFER_VERSION;
555 chlg_desc.cBuffers = 3;
556 chlg_desc.pBuffers = chlg_buf;
557 chlg_buf[0].BufferType = SECBUFFER_TOKEN;
558 chlg_buf[0].pvBuffer = digest->input_token;
559 chlg_buf[0].cbBuffer =
curlx_uztoul(digest->input_token_len);
560 chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
561 chlg_buf[1].pvBuffer = (
void *) request;
562 chlg_buf[1].cbBuffer =
curlx_uztoul(strlen((
const char *) request));
563 chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
564 chlg_buf[2].pvBuffer = NULL;
565 chlg_buf[2].cbBuffer = 0;
568 resp_desc.ulVersion = SECBUFFER_VERSION;
569 resp_desc.cBuffers = 1;
570 resp_desc.pBuffers = &resp_buf;
571 resp_buf.BufferType = SECBUFFER_TOKEN;
572 resp_buf.pvBuffer = output_token;
575 spn = Curl_convert_UTF8_to_tchar((
char *) uripath);
577 s_pSecFn->FreeCredentialsHandle(&credentials);
579 Curl_sspi_free_identity(p_identity);
586 digest->http_context =
calloc(1,
sizeof(CtxtHandle));
587 if(!digest->http_context)
591 status = s_pSecFn->InitializeSecurityContext(&credentials, NULL,
593 ISC_REQ_USE_HTTP_STYLE, 0, 0,
595 digest->http_context,
596 &resp_desc, &attrs, &expiry);
597 Curl_unicodefree(spn);
599 if(status == SEC_I_COMPLETE_NEEDED ||
600 status == SEC_I_COMPLETE_AND_CONTINUE)
601 s_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
602 else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
603 s_pSecFn->FreeCredentialsHandle(&credentials);
605 Curl_sspi_free_identity(p_identity);
613 output_token_len = resp_buf.cbBuffer;
615 s_pSecFn->FreeCredentialsHandle(&credentials);
616 Curl_sspi_free_identity(p_identity);
619 resp =
malloc(output_token_len + 1);
627 memcpy(resp, output_token, output_token_len);
628 resp[output_token_len] = 0;
632 *outlen = output_token_len;
656 digest->input_token_len = 0;
659 if(digest->http_context) {
660 s_pSecFn->DeleteSecurityContext(digest->http_context);
CURLcode Curl_base64_decode(const char *src, unsigned char **outptr, size_t *outlen)
CURLcode Curl_base64_encode(struct Curl_easy *data, const char *inputbuff, size_t insize, char **outptr, size_t *outlen)
void * Curl_memdup(const void *src, size_t length)
#define strcasecompare(a, b)
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)
UNITTEST_START int result
#define DIGEST_MAX_CONTENT_LENGTH
struct connectdata * easy_conn
memcpy(filename, filename1, strlen(filename1))
unsigned long curlx_uztoul(size_t uznum)
CURLcode Curl_auth_create_digest_md5_message(struct Curl_easy *data, const char *chlg64, const char *userp, const char *passwdp, const char *service, char **outptr, size_t *outlen)
CURLcode Curl_auth_decode_digest_http_message(const char *chlg, struct digestdata *digest)
bool Curl_auth_is_digest_supported(void)
void Curl_auth_digest_cleanup(struct digestdata *digest)
#define Curl_safefree(ptr)
char * Curl_auth_build_spn(const char *service, const char *host, const char *realm)
UNITTEST_START int * value
#define DIGEST_MAX_VALUE_LENGTH
bool Curl_auth_digest_get_pair(const char *str, char *value, char *content, const char **endptr)
#define calloc(nbelem, size)