Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/curl/lib/vauth/digest.c @ 2:b50eed0cc0ef upstream

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