Annotation of embedaddon/curl/lib/vauth/digest.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, 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, b, strlen(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: * 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 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: const size_t))
693: {
694: CURLcode result;
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;
703: char *response = NULL;
704: char *hashthis = NULL;
705: char *tmp = NULL;
706:
707: if(!digest->nc)
708: digest->nc = 1;
709:
710: if(!digest->cnonce) {
711: char cnoncebuf[33];
712: result = Curl_rand_hex(data, (unsigned char *)cnoncebuf,
713: sizeof(cnoncebuf));
714: if(result)
715: return result;
716:
717: result = Curl_base64_encode(data, cnoncebuf, strlen(cnoncebuf),
718: &cnonce, &cnonce_sz);
719: if(result)
720: return result;
721:
722: digest->cnonce = cnonce;
723: }
724:
725: if(digest->userhash) {
726: hashthis = aprintf("%s:%s", userp, digest->realm);
727: if(!hashthis)
728: return CURLE_OUT_OF_MEMORY;
729:
730: CURL_OUTPUT_DIGEST_CONV(data, hashthis);
731: hash(hashbuf, (unsigned char *) hashthis, strlen(hashthis));
732: free(hashthis);
733: convert_to_ascii(hashbuf, (unsigned char *)userh);
734: }
735:
736: /*
737: If the algorithm is "MD5" or unspecified (which then defaults to MD5):
738:
739: A1 = unq(username-value) ":" unq(realm-value) ":" passwd
740:
741: If the algorithm is "MD5-sess" then:
742:
743: A1 = H(unq(username-value) ":" unq(realm-value) ":" passwd) ":"
744: unq(nonce-value) ":" unq(cnonce-value)
745: */
746:
747: hashthis = 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, (unsigned char *) hashthis, strlen(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, strlen(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 = 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: char *hashthis2;
792:
793: hash(hashbuf, (const unsigned char *)"", 0);
794: convert_to_ascii(hashbuf, (unsigned char *)hashed);
795:
796: hashthis2 = 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, (unsigned char *) hashthis, strlen(hashthis));
806: free(hashthis);
807: convert_to_ascii(hashbuf, ha2);
808:
809: if(digest->qop) {
810: hashthis = aprintf("%s:%s:%08x:%s:%s:%s", ha1, digest->nonce, digest->nc,
811: digest->cnonce, digest->qop, ha2);
812: }
813: else {
814: hashthis = aprintf("%s:%s:%s", ha1, digest->nonce, ha2);
815: }
816:
817: if(!hashthis)
818: return CURLE_OUT_OF_MEMORY;
819:
820: CURL_OUTPUT_DIGEST_CONV(data, hashthis); /* convert on non-ASCII machines */
821: hash(hashbuf, (unsigned char *) hashthis, strlen(hashthis));
822: free(hashthis);
823: convert_to_ascii(hashbuf, request_digest);
824:
825: /* For test case 64 (snooped from a Mozilla 1.3a request)
826:
827: Authorization: Digest username="testuser", realm="testrealm", \
828: nonce="1053604145", uri="/64", response="c55f7f30d83d774a3d2dcacf725abaca"
829:
830: Digest parameters are all quoted strings. Username which is provided by
831: the user will need double quotes and backslashes within it escaped. For
832: the other fields, this shouldn't be an issue. realm, nonce, and opaque
833: are copied as is from the server, escapes and all. cnonce is generated
834: with web-safe characters. uri is already percent encoded. nc is 8 hex
835: characters. algorithm and qop with standard values only contain web-safe
836: characters.
837: */
838: userp_quoted = auth_digest_string_quoted(digest->userhash ? userh : userp);
839: if(!userp_quoted)
840: return CURLE_OUT_OF_MEMORY;
841:
842: if(digest->qop) {
843: response = aprintf("username=\"%s\", "
844: "realm=\"%s\", "
845: "nonce=\"%s\", "
846: "uri=\"%s\", "
847: "cnonce=\"%s\", "
848: "nc=%08x, "
849: "qop=%s, "
850: "response=\"%s\"",
851: userp_quoted,
852: digest->realm,
853: digest->nonce,
854: uripath,
855: digest->cnonce,
856: digest->nc,
857: digest->qop,
858: request_digest);
859:
860: if(strcasecompare(digest->qop, "auth"))
861: digest->nc++; /* The nc (from RFC) has to be a 8 hex digit number 0
862: padded which tells to the server how many times you are
863: using the same nonce in the qop=auth mode */
864: }
865: else {
866: response = aprintf("username=\"%s\", "
867: "realm=\"%s\", "
868: "nonce=\"%s\", "
869: "uri=\"%s\", "
870: "response=\"%s\"",
871: userp_quoted,
872: digest->realm,
873: digest->nonce,
874: uripath,
875: request_digest);
876: }
877: free(userp_quoted);
878: if(!response)
879: return CURLE_OUT_OF_MEMORY;
880:
881: /* Add the optional fields */
882: if(digest->opaque) {
883: /* Append the opaque */
884: tmp = aprintf("%s, opaque=\"%s\"", response, digest->opaque);
885: free(response);
886: if(!tmp)
887: return CURLE_OUT_OF_MEMORY;
888:
889: response = tmp;
890: }
891:
892: if(digest->algorithm) {
893: /* Append the algorithm */
894: tmp = aprintf("%s, algorithm=%s", response, digest->algorithm);
895: free(response);
896: if(!tmp)
897: return CURLE_OUT_OF_MEMORY;
898:
899: response = tmp;
900: }
901:
902: if(digest->userhash) {
903: /* Append the userhash */
904: tmp = aprintf("%s, userhash=true", response);
905: free(response);
906: if(!tmp)
907: return CURLE_OUT_OF_MEMORY;
908:
909: response = tmp;
910: }
911:
912: /* Return the output */
913: *outptr = response;
914: *outlen = strlen(response);
915:
916: return CURLE_OK;
917: }
918:
919: /*
920: * Curl_auth_create_digest_http_message()
921: *
922: * This is used to generate a HTTP DIGEST response message ready for sending
923: * to the recipient.
924: *
925: * Parameters:
926: *
927: * data [in] - The session handle.
928: * userp [in] - The user name.
929: * passwdp [in] - The user's password.
930: * request [in] - The HTTP request.
931: * uripath [in] - The path of the HTTP uri.
932: * digest [in/out] - The digest data struct being used and modified.
933: * outptr [in/out] - The address where a pointer to newly allocated memory
934: * holding the result will be stored upon completion.
935: * outlen [out] - The length of the output message.
936: *
937: * Returns CURLE_OK on success.
938: */
939: CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
940: const char *userp,
941: const char *passwdp,
942: const unsigned char *request,
943: const unsigned char *uripath,
944: struct digestdata *digest,
945: char **outptr, size_t *outlen)
946: {
947: switch(digest->algo) {
948: case CURLDIGESTALGO_MD5:
949: case CURLDIGESTALGO_MD5SESS:
950: return auth_create_digest_http_message(data, userp, passwdp,
951: request, uripath, digest,
952: outptr, outlen,
953: auth_digest_md5_to_ascii,
954: Curl_md5it);
955:
956: case CURLDIGESTALGO_SHA256:
957: case CURLDIGESTALGO_SHA256SESS:
958: case CURLDIGESTALGO_SHA512_256:
959: case CURLDIGESTALGO_SHA512_256SESS:
960: return auth_create_digest_http_message(data, userp, passwdp,
961: request, uripath, digest,
962: outptr, outlen,
963: auth_digest_sha256_to_ascii,
964: Curl_sha256it);
965:
966: default:
967: return CURLE_UNSUPPORTED_PROTOCOL;
968: }
969: }
970:
971: /*
972: * Curl_auth_digest_cleanup()
973: *
974: * This is used to clean up the digest specific data.
975: *
976: * Parameters:
977: *
978: * digest [in/out] - The digest data struct being cleaned up.
979: *
980: */
981: void Curl_auth_digest_cleanup(struct digestdata *digest)
982: {
983: Curl_safefree(digest->nonce);
984: Curl_safefree(digest->cnonce);
985: Curl_safefree(digest->realm);
986: Curl_safefree(digest->opaque);
987: Curl_safefree(digest->qop);
988: Curl_safefree(digest->algorithm);
989:
990: digest->nc = 0;
991: digest->algo = CURLDIGESTALGO_MD5; /* default algorithm */
992: digest->stale = FALSE; /* default means normal, not stale */
993: digest->userhash = FALSE;
994: }
995: #endif /* !USE_WINDOWS_SSPI */
996:
997: #endif /* CURL_DISABLE_CRYPTO_AUTH */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to digest.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib / vauth