MAC Cookies (patch 4 of N)

net/http/http_mac_signature.cc

 // Copyright (c) 2011 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_mac_signature.h"
 
 #include "base/base64.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 34 matching lines @@
 
 HttpMacSignature::HttpMacSignature()
     : mac_algorithm_(crypto::HMAC::SHA1) {
 }
 
 HttpMacSignature::~HttpMacSignature() {
 }
 
 bool HttpMacSignature::AddStateInfo(const std::string& id,
                                     const std::string& mac_key,
-                                    const std::string& mac_algorithm,
-                                    const std::string& issuer) {
+                                    const std::string& mac_algorithm) {
   DCHECK(id_.empty());
 
   if (!IsPlainString(id) || id.empty() ||
       mac_key.empty() ||
-      mac_algorithm.empty() ||
-      !IsPlainString(issuer) || issuer.empty()) {
+      mac_algorithm.empty()) {
     return false;
   }
 
   if (mac_algorithm == kSHA1Name)
     mac_algorithm_ = crypto::HMAC::SHA1;
   else if (mac_algorithm == kSHA256Name)
     mac_algorithm_ = crypto::HMAC::SHA256;
   else
     return false;
 
   id_ = id;
   mac_key_ = mac_key;
-  issuer_ = issuer;
   return true;
 }
 
 bool HttpMacSignature::AddHttpInfo(const std::string& method,
                                    const std::string& request_uri,
                                    const std::string& host,
                                    int port) {
   DCHECK(method_.empty());
 
   if (!IsPlainString(method) || method.empty() ||
@@ skipping 24 matching lines @@
 std::string HttpMacSignature::GenerateHeaderString(
     const std::string& timestamp,
     const std::string& nonce) {
   std::string mac = GenerateMAC(timestamp, nonce);
 
   DCHECK(IsPlainString(timestamp));
   DCHECK(IsPlainString(nonce));
   DCHECK(IsPlainString(mac));
 
   return "MAC id=\"" + id_ +
-      "\", issuer=\"" + issuer_ +

[cbentzel, 2011/05/13 17:55:29]

uhh, why'd you get rid of the issuer? Is this a change to the spec? Are you
assuming only one key namespace per eTLD+1?

-      "\", timestamp=\"" + timestamp +
-      "\", nonce=\"" + nonce +
+      "\", nonce=\"" + timestamp + ":" + nonce +
       "\", mac=\"" + mac + "\"";
 }
 
 std::string HttpMacSignature::GenerateNormalizedRequest(
     const std::string& timestamp,
     const std::string& nonce) {
   static const std::string kNewLine = "\n";
 
-  std::string normalized_request = id_ + kNewLine;
-  normalized_request += issuer_ + kNewLine;
-  normalized_request += timestamp + kNewLine;
-  normalized_request += nonce + kNewLine;
+  std::string normalized_request = timestamp + ":" + nonce + kNewLine;
   normalized_request += method_ + kNewLine;
   normalized_request += request_uri_ + kNewLine;
   normalized_request += host_ + kNewLine;
   normalized_request += port_ + kNewLine;
+  normalized_request += kNewLine;
+  normalized_request += kNewLine;
 
   return normalized_request;
 }
 
 std::string HttpMacSignature::GenerateMAC(const std::string& timestamp,
                                           const std::string& nonce) {
   std::string request = GenerateNormalizedRequest(timestamp, nonce);
 
   crypto::HMAC hmac(mac_algorithm_);
   hmac.Init(mac_key_);
 
   std::string signature;
   size_t length = hmac.DigestLength();
   char* buffer = WriteInto(&signature, length);
   bool result = hmac.Sign(request,
                           reinterpret_cast<unsigned char*>(buffer),
                           length);
   DCHECK(result);
 
   std::string encoded_signature;
   result = base::Base64Encode(signature, &encoded_signature);
   DCHECK(result);
   return encoded_signature;
 }
 
 }  // namespace net