auth-int qop is ignored for Digest authentication

net/http/http_auth_handler_digest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_auth_handler_digest.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_util.h"
 
-// TODO(eroman): support qop=auth-int
-
 namespace net {
 
 // Digest authentication is specified in RFC 2617.
 // The expanded derivations are listed in the tables below.
 
 //==========+==========+==========================================+
 //    qop   |algorithm |               response                   |
 //==========+==========+==========================================+
 //    ?     |  ?, md5, | MD5(MD5(A1):nonce:MD5(A2))               |
 //          | md5-sess |                                          |
@@ skipping 25 matching lines @@
   if (fixed_cnonce_)
     return std::string(domain);
   std::string cnonce;
   cnonce.reserve(16);
   for (int i = 0; i < 16; ++i)
     cnonce.push_back(domain[base::RandInt(0, 15)]);
   return cnonce;
 }
 
 // static
-std::string HttpAuthHandlerDigest::QopToString(int qop) {
+std::string HttpAuthHandlerDigest::QopToString(QualityOfProtection qop) {
   switch (qop) {
+    case QOP_UNSPECIFIED:
+      return "";
     case QOP_AUTH:
       return "auth";
-    case QOP_AUTH_INT:
-      return "auth-int";
     default:
+      NOTREACHED();
       return "";
   }
 }
 
 // static
-std::string HttpAuthHandlerDigest::AlgorithmToString(int algorithm) {
+std::string HttpAuthHandlerDigest::AlgorithmToString(
+    DigestAlgorithm algorithm) {
   switch (algorithm) {
+    case ALGORITHM_UNSPECIFIED:
+      return "";
     case ALGORITHM_MD5:
       return "MD5";
     case ALGORITHM_MD5_SESS:
       return "MD5-sess";
     default:
+      NOTREACHED();
       return "";
   }
 }
 
 HttpAuthHandlerDigest::HttpAuthHandlerDigest(int nonce_count)
     : stale_(false),
       algorithm_(ALGORITHM_UNSPECIFIED),
-      qop_(0),
+      qop_(QOP_UNSPECIFIED),
       nonce_count_(nonce_count) {
 }
 
 HttpAuthHandlerDigest::~HttpAuthHandlerDigest() {
 }
 
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
     const string16* username,
     const string16* password,
     const HttpRequestInfo* request,
@@ skipping 196 matching lines @@
     if (LowerCaseEqualsASCII(value, "md5")) {
       algorithm_ = ALGORITHM_MD5;
     } else if (LowerCaseEqualsASCII(value, "md5-sess")) {
       algorithm_ = ALGORITHM_MD5_SESS;
     } else {
       DVLOG(1) << "Unknown value of algorithm";
       return false;  // FAIL -- unsupported value of algorithm.
     }
   } else if (LowerCaseEqualsASCII(name, "qop")) {
     // Parse the comma separated list of qops.
+    // auth is the only supported qop, and all other values are ignored.
     HttpUtil::ValuesIterator qop_values(value.begin(), value.end(), ',');
+    qop_ = QOP_UNSPECIFIED;
     while (qop_values.GetNext()) {
       if (LowerCaseEqualsASCII(qop_values.value(), "auth")) {
-        qop_ |= QOP_AUTH;
-      } else if (LowerCaseEqualsASCII(qop_values.value(), "auth-int")) {
-        qop_ |= QOP_AUTH_INT;
+        qop_ = QOP_AUTH;
+        break;
       }
     }
   } else {
     DVLOG(1) << "Skipping unrecognized digest property";
     // TODO(eroman): perhaps we should fail instead of silently skipping?
   }
   return true;
 }
 
 HttpAuthHandlerDigest::Factory::Factory() {
@@ skipping 14 matching lines @@
   //                 method and only constructing when valid.
   scoped_ptr<HttpAuthHandler> tmp_handler(
       new HttpAuthHandlerDigest(digest_nonce_count));
   if (!tmp_handler->InitFromChallenge(challenge, target, origin, net_log))
     return ERR_INVALID_RESPONSE;
   handler->swap(tmp_handler);
   return OK;
 }
 
 }  // namespace net