D:/opendownloadmanager/ODM-1.x/InetFile/cURL_lib/http

00001 /***************************************************************************
00002  *                                  _   _ ____  _
00003  *  Project                     ___| | | |  _ \| |
00004  *                             / __| | | | |_) | |
00005  *                            | (__| |_| |  _ <| |___
00006  *                             \___|\___/|_| \_\_____|
00007  *
00008  * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
00009  *
00010  * This software is licensed as described in the file COPYING, which
00011  * you should have received as part of this distribution. The terms
00012  * are also available at http://curl.haxx.se/docs/copyright.html.
00013  *
00014  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
00015  * copies of the Software, and permit persons to whom the Software is
00016  * furnished to do so, under the terms of the COPYING file.
00017  *
00018  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
00019  * KIND, either express or implied.
00020  *
00021  * $Id: http_digest.c,v 1.29 2007-02-26 22:03:01 bagder Exp $
00022  ***************************************************************************/
00023 #include "setup.h"
00024 
00025 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_CRYPTO_AUTH)
00026 /* -- WIN32 approved -- */
00027 #include <stdio.h>
00028 #include <string.h>
00029 #include <stdarg.h>
00030 #include <stdlib.h>
00031 #include <ctype.h>
00032 
00033 #include "urldata.h"
00034 #include "sendf.h"
00035 #include "strequal.h"
00036 #include "base64.h"
00037 #include "md5.h"
00038 #include "http_digest.h"
00039 #include "strtok.h"
00040 #include "url.h" /* for Curl_safefree() */
00041 #include "memory.h"
00042 #include "easyif.h" /* included for Curl_convert_... prototypes */
00043 
00044 #define _MPRINTF_REPLACE /* use our functions only */
00045 #include <curl/mprintf.h>
00046 
00047 /* The last #include file should be: */
00048 #include "memdebug.h"
00049 
00050 /* Test example headers:
00051 
00052 WWW-Authenticate: Digest realm="testrealm", nonce="1053604598"
00053 Proxy-Authenticate: Digest realm="testrealm", nonce="1053604598"
00054 
00055 */
00056 
00057 CURLdigest Curl_input_digest(struct connectdata *conn,
00058                              bool proxy,
00059                              char *header) /* rest of the *-authenticate:
00060                                               header */
00061 {
00062   bool more = TRUE;
00063   char *token = NULL;
00064   char *tmp = NULL;
00065   bool foundAuth = FALSE;
00066   bool foundAuthInt = FALSE;
00067   struct SessionHandle *data=conn->data;
00068   bool before = FALSE; /* got a nonce before */
00069   struct digestdata *d;
00070 
00071   if(proxy) {
00072     d = &data->state.proxydigest;
00073   }
00074   else {
00075     d = &data->state.digest;
00076   }
00077 
00078   /* skip initial whitespaces */
00079   while(*header && ISSPACE(*header))
00080     header++;
00081 
00082   if(checkprefix("Digest", header)) {
00083     header += strlen("Digest");
00084 
00085     /* If we already have received a nonce, keep that in mind */
00086     if(d->nonce)
00087       before = TRUE;
00088 
00089     /* clear off any former leftovers and init to defaults */
00090     Curl_digest_cleanup_one(d);
00091 
00092     while(more) {
00093       char value[32];
00094       char content[128];
00095       size_t totlen=0;
00096 
00097       while(*header && ISSPACE(*header))
00098         header++;
00099 
00100       /* how big can these strings be? */
00101       if((2 == sscanf(header, "%31[^=]=\"%127[^\"]\"",
00102                       value, content)) ||
00103          /* try the same scan but without quotes around the content but don't
00104             include the possibly trailing comma, newline or carriage return */
00105          (2 ==  sscanf(header, "%31[^=]=%127[^\r\n,]",
00106                        value, content)) ) {
00107         if(strequal(value, "nonce")) {
00108           d->nonce = strdup(content);
00109           if(!d->nonce)
00110             return CURLDIGEST_NOMEM;
00111         }
00112         else if(strequal(value, "stale")) {
00113           if(strequal(content, "true")) {
00114             d->stale = TRUE;
00115             d->nc = 1; /* we make a new nonce now */
00116           }
00117         }
00118         else if(strequal(value, "realm")) {
00119           d->realm = strdup(content);
00120           if(!d->realm)
00121             return CURLDIGEST_NOMEM;
00122         }
00123         else if(strequal(value, "opaque")) {
00124           d->opaque = strdup(content);
00125           if(!d->opaque)
00126             return CURLDIGEST_NOMEM;
00127         }
00128         else if(strequal(value, "qop")) {
00129           char *tok_buf;
00130           /* tokenize the list and choose auth if possible, use a temporary
00131              clone of the buffer since strtok_r() ruins it */
00132           tmp = strdup(content);
00133           if(!tmp)
00134             return CURLDIGEST_NOMEM;
00135           token = strtok_r(tmp, ",", &tok_buf);
00136           while (token != NULL) {
00137             if (strequal(token, "auth")) {
00138               foundAuth = TRUE;
00139             }
00140             else if (strequal(token, "auth-int")) {
00141               foundAuthInt = TRUE;
00142             }
00143             token = strtok_r(NULL, ",", &tok_buf);
00144           }
00145           free(tmp);
00146           /*select only auth o auth-int. Otherwise, ignore*/
00147           if (foundAuth) {
00148             d->qop = strdup("auth");
00149             if(!d->qop)
00150               return CURLDIGEST_NOMEM;
00151           }
00152           else if (foundAuthInt) {
00153             d->qop = strdup("auth-int");
00154             if(!d->qop)
00155               return CURLDIGEST_NOMEM;
00156           }
00157         }
00158         else if(strequal(value, "algorithm")) {
00159           d->algorithm = strdup(content);
00160           if(!d->algorithm)
00161             return CURLDIGEST_NOMEM;
00162           if(strequal(content, "MD5-sess"))
00163             d->algo = CURLDIGESTALGO_MD5SESS;
00164           else if(strequal(content, "MD5"))
00165             d->algo = CURLDIGESTALGO_MD5;
00166           else
00167             return CURLDIGEST_BADALGO;
00168         }
00169         else {
00170           /* unknown specifier, ignore it! */
00171         }
00172         totlen = strlen(value)+strlen(content)+1;
00173 
00174         if(header[strlen(value)+1] == '\"')
00175           /* the contents were within quotes, then add 2 for them to the
00176              length */
00177           totlen += 2;
00178       }
00179       else
00180         break; /* we're done here */
00181 
00182       header += totlen;
00183       if(',' == *header)
00184         /* allow the list to be comma-separated */
00185         header++;
00186     }
00187     /* We had a nonce since before, and we got another one now without
00188        'stale=true'. This means we provided bad credentials in the previous
00189        request */
00190     if(before && !d->stale)
00191       return CURLDIGEST_BAD;
00192 
00193     /* We got this header without a nonce, that's a bad Digest line! */
00194     if(!d->nonce)
00195       return CURLDIGEST_BAD;
00196   }
00197   else
00198     /* else not a digest, get out */
00199     return CURLDIGEST_NONE;
00200 
00201   return CURLDIGEST_FINE;
00202 }
00203 
00204 /* convert md5 chunk to RFC2617 (section 3.1.3) -suitable ascii string*/
00205 static void md5_to_ascii(unsigned char *source, /* 16 bytes */
00206                          unsigned char *dest) /* 33 bytes */
00207 {
00208   int i;
00209   for(i=0; i<16; i++)
00210     snprintf((char *)&dest[i*2], 3, "%02x", source[i]);
00211 }
00212 
00213 CURLcode Curl_output_digest(struct connectdata *conn,
00214                             bool proxy,
00215                             unsigned char *request,
00216                             unsigned char *uripath)
00217 {
00218   /* We have a Digest setup for this, use it!  Now, to get all the details for
00219      this sorted out, I must urge you dear friend to read up on the RFC2617
00220      section 3.2.2, */
00221   unsigned char md5buf[16]; /* 16 bytes/128 bits */
00222   unsigned char request_digest[33];
00223   unsigned char *md5this;
00224   unsigned char *ha1;
00225   unsigned char ha2[33];/* 32 digits and 1 zero byte */
00226   char cnoncebuf[7];
00227   char *cnonce;
00228   char *tmp = NULL;
00229   struct timeval now;
00230 
00231   char **allocuserpwd;
00232   char *userp;
00233   char *passwdp;
00234   struct auth *authp;
00235 
00236   struct SessionHandle *data = conn->data;
00237   struct digestdata *d;
00238 #ifdef CURL_DOES_CONVERSIONS
00239   CURLcode rc;
00240 /* The CURL_OUTPUT_DIGEST_CONV macro below is for non-ASCII machines.
00241    It converts digest text to ASCII so the MD5 will be correct for 
00242    what ultimately goes over the network.
00243 */
00244 #define CURL_OUTPUT_DIGEST_CONV(a, b) \
00245   rc = Curl_convert_to_network(a, (char *)b, strlen((const char*)b)); \
00246   if (rc != CURLE_OK) { \
00247     free(b); \
00248     return rc; \
00249   }
00250 #else
00251 #define CURL_OUTPUT_DIGEST_CONV(a, b)
00252 #endif /* CURL_DOES_CONVERSIONS */
00253 
00254   if(proxy) {
00255     d = &data->state.proxydigest;
00256     allocuserpwd = &conn->allocptr.proxyuserpwd;
00257     userp = conn->proxyuser;
00258     passwdp = conn->proxypasswd;
00259     authp = &data->state.authproxy;
00260   }
00261   else {
00262     d = &data->state.digest;
00263     allocuserpwd = &conn->allocptr.userpwd;
00264     userp = conn->user;
00265     passwdp = conn->passwd;
00266     authp = &data->state.authhost;
00267   }
00268 
00269   /* not set means empty */
00270   if(!userp)
00271     userp=(char *)"";
00272 
00273   if(!passwdp)
00274     passwdp=(char *)"";
00275 
00276   if(!d->nonce) {
00277     authp->done = FALSE;
00278     return CURLE_OK;
00279   }
00280   authp->done = TRUE;
00281 
00282   if(!d->nc)
00283     d->nc = 1;
00284 
00285   if(!d->cnonce) {
00286     /* Generate a cnonce */
00287     now = Curl_tvnow();
00288     snprintf(cnoncebuf, sizeof(cnoncebuf), "%06ld", now.tv_sec);
00289     if(Curl_base64_encode(data, cnoncebuf, strlen(cnoncebuf), &cnonce))
00290       d->cnonce = cnonce;
00291     else
00292       return CURLE_OUT_OF_MEMORY;
00293   }
00294 
00295   /*
00296     if the algorithm is "MD5" or unspecified (which then defaults to MD5):
00297 
00298     A1 = unq(username-value) ":" unq(realm-value) ":" passwd
00299 
00300     if the algorithm is "MD5-sess" then:
00301 
00302     A1 = H( unq(username-value) ":" unq(realm-value) ":" passwd )
00303          ":" unq(nonce-value) ":" unq(cnonce-value)
00304   */
00305 
00306   md5this = (unsigned char *)
00307     aprintf("%s:%s:%s", userp, d->realm, passwdp);
00308   if(!md5this)
00309     return CURLE_OUT_OF_MEMORY;
00310 
00311   CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
00312   Curl_md5it(md5buf, md5this);
00313   free(md5this); /* free this again */
00314 
00315   ha1 = (unsigned char *)malloc(33); /* 32 digits and 1 zero byte */
00316   if(!ha1)
00317     return CURLE_OUT_OF_MEMORY;
00318 
00319   md5_to_ascii(md5buf, ha1);
00320 
00321   if(d->algo == CURLDIGESTALGO_MD5SESS) {
00322     /* nonce and cnonce are OUTSIDE the hash */
00323     tmp = aprintf("%s:%s:%s", ha1, d->nonce, d->cnonce);
00324     if(!tmp)
00325       return CURLE_OUT_OF_MEMORY;
00326     CURL_OUTPUT_DIGEST_CONV(data, tmp); /* convert on non-ASCII machines */
00327     Curl_md5it(md5buf, (unsigned char *)tmp);
00328     free(tmp); /* free this again */
00329     md5_to_ascii(md5buf, ha1);
00330   }
00331 
00332   /*
00333     If the "qop" directive's value is "auth" or is unspecified, then A2 is:
00334 
00335       A2       = Method ":" digest-uri-value
00336 
00337           If the "qop" value is "auth-int", then A2 is:
00338 
00339       A2       = Method ":" digest-uri-value ":" H(entity-body)
00340 
00341     (The "Method" value is the HTTP request method as specified in section
00342     5.1.1 of RFC 2616)
00343   */
00344 
00345   md5this = (unsigned char *)aprintf("%s:%s", request, uripath);
00346   if(!md5this) {
00347     free(ha1);
00348     return CURLE_OUT_OF_MEMORY;
00349   }
00350 
00351   if (d->qop && strequal(d->qop, "auth-int")) {
00352     /* We don't support auth-int at the moment. I can't see a easy way to get
00353        entity-body here */
00354     /* TODO: Append H(entity-body)*/
00355   }
00356   CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
00357   Curl_md5it(md5buf, md5this);
00358   free(md5this); /* free this again */
00359   md5_to_ascii(md5buf, ha2);
00360 
00361   if (d->qop) {
00362     md5this = (unsigned char *)aprintf("%s:%s:%08x:%s:%s:%s",
00363                                        ha1,
00364                                        d->nonce,
00365                                        d->nc,
00366                                        d->cnonce,
00367                                        d->qop,
00368                                        ha2);
00369   }
00370   else {
00371     md5this = (unsigned char *)aprintf("%s:%s:%s",
00372                                        ha1,
00373                                        d->nonce,
00374                                        ha2);
00375   }
00376   free(ha1);
00377   if(!md5this)
00378     return CURLE_OUT_OF_MEMORY;
00379 
00380   CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
00381   Curl_md5it(md5buf, md5this);
00382   free(md5this); /* free this again */
00383   md5_to_ascii(md5buf, request_digest);
00384 
00385   /* for test case 64 (snooped from a Mozilla 1.3a request)
00386 
00387     Authorization: Digest username="testuser", realm="testrealm", \
00388     nonce="1053604145", uri="/64", response="c55f7f30d83d774a3d2dcacf725abaca"
00389   */
00390 
00391   Curl_safefree(*allocuserpwd);
00392 
00393   if (d->qop) {
00394     *allocuserpwd =
00395       aprintf( "%sAuthorization: Digest "
00396                "username=\"%s\", "
00397                "realm=\"%s\", "
00398                "nonce=\"%s\", "
00399                "uri=\"%s\", "
00400                "cnonce=\"%s\", "
00401                "nc=%08x, "
00402                "qop=\"%s\", "
00403                "response=\"%s\"",
00404                proxy?"Proxy-":"",
00405                userp,
00406                d->realm,
00407                d->nonce,
00408                uripath, /* this is the PATH part of the URL */
00409                d->cnonce,
00410                d->nc,
00411                d->qop,
00412                request_digest);
00413 
00414     if(strequal(d->qop, "auth"))
00415       d->nc++; /* The nc (from RFC) has to be a 8 hex digit number 0 padded
00416                   which tells to the server how many times you are using the
00417                   same nonce in the qop=auth mode. */
00418   }
00419   else {
00420     *allocuserpwd =
00421       aprintf( "%sAuthorization: Digest "
00422                "username=\"%s\", "
00423                "realm=\"%s\", "
00424                "nonce=\"%s\", "
00425                "uri=\"%s\", "
00426                "response=\"%s\"",
00427                proxy?"Proxy-":"",
00428                userp,
00429                d->realm,
00430                d->nonce,
00431                uripath, /* this is the PATH part of the URL */
00432                request_digest);
00433   }
00434   if(!*allocuserpwd)
00435     return CURLE_OUT_OF_MEMORY;
00436 
00437   /* Add optional fields */
00438   if(d->opaque) {
00439     /* append opaque */
00440     tmp = aprintf("%s, opaque=\"%s\"", *allocuserpwd, d->opaque);
00441     if(!tmp)
00442       return CURLE_OUT_OF_MEMORY;
00443     free(*allocuserpwd);
00444     *allocuserpwd = tmp;
00445   }
00446 
00447   if(d->algorithm) {
00448     /* append algorithm */
00449     tmp = aprintf("%s, algorithm=\"%s\"", *allocuserpwd, d->algorithm);
00450     if(!tmp)
00451       return CURLE_OUT_OF_MEMORY;
00452     free(*allocuserpwd);
00453     *allocuserpwd = tmp;
00454   }
00455 
00456   /* append CRLF to the userpwd header */
00457   tmp = (char*) realloc(*allocuserpwd, strlen(*allocuserpwd) + 3 + 1);
00458   if(!tmp)
00459     return CURLE_OUT_OF_MEMORY;
00460   strcat(tmp, "\r\n");
00461   *allocuserpwd = tmp;
00462 
00463   return CURLE_OK;
00464 }
00465 
00466 void Curl_digest_cleanup_one(struct digestdata *d)
00467 {
00468   if(d->nonce)
00469     free(d->nonce);
00470   d->nonce = NULL;
00471 
00472   if(d->cnonce)
00473     free(d->cnonce);
00474   d->cnonce = NULL;
00475 
00476   if(d->realm)
00477     free(d->realm);
00478   d->realm = NULL;
00479 
00480   if(d->opaque)
00481     free(d->opaque);
00482   d->opaque = NULL;
00483 
00484   if(d->qop)
00485     free(d->qop);
00486   d->qop = NULL;
00487 
00488   if(d->algorithm)
00489     free(d->algorithm);
00490   d->algorithm = NULL;
00491 
00492   d->nc = 0;
00493   d->algo = CURLDIGESTALGO_MD5; /* default algorithm */
00494   d->stale = FALSE; /* default means normal, not stale */
00495 }
00496 
00497 
00498 void Curl_digest_cleanup(struct SessionHandle *data)
00499 {
00500   Curl_digest_cleanup_one(&data->state.digest);
00501   Curl_digest_cleanup_one(&data->state.proxydigest);
00502 }
00503 
00504 #endif
D:/opendownloadmanager/ODM-1.x/InetFile/cURL_lib/http_digest.c
