Implement $Secure- cookie prefix

net/cookies/cookie_monster.cc

 // Copyright (c) 2012 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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 313 matching lines @@
   return cookie_line;
 }
 
 void RunAsync(scoped_refptr<base::TaskRunner> proxy,
               const CookieStore::CookieChangedCallback& callback,
               const CanonicalCookie& cookie,
               bool removed) {
   proxy->PostTask(FROM_HERE, base::Bind(callback, cookie, removed));
 }
 
+bool CheckCookiePrefix(CanonicalCookie* cc, const CookieOptions& options) {
+  const char kSecurePrefix[] = "$Secure-";
+  if (cc->Name().find(kSecurePrefix) == 0)

[Mike West, 2015/10/12 10:59:04]

Let's lock this down to CanonicalCookies whose `Source()`s whose
`SchemeIsCryptographic()`. I'm updating the spec, as we discussed. :)

[estark, 2015/10/12 11:39:43]

Done.

+    return cc->IsSecure();
+  return true;
+}
+
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : initialized_(false),
       started_fetching_all_cookies_(false),
       finished_fetching_all_cookies_(false),
       fetch_strategy_(kUnknownFetch),
       store_(store),
       last_access_threshold_(
@@ skipping 88 matching lines @@
   SetCookieWithDetailsTask(CookieMonster* cookie_monster,
                            const GURL& url,
                            const std::string& name,
                            const std::string& value,
                            const std::string& domain,
                            const std::string& path,
                            const base::Time& expiration_time,
                            bool secure,
                            bool http_only,
                            bool first_party_only,
+                           bool enforce_prefixes,
                            CookiePriority priority,
                            const SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         name_(name),
         value_(value),
         domain_(domain),
         path_(path),
         expiration_time_(expiration_time),
         secure_(secure),
         http_only_(http_only),
         first_party_only_(first_party_only),
+        enforce_prefixes_(enforce_prefixes),
         priority_(priority),
         callback_(callback) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetCookieWithDetailsTask() override {}
 
  private:
   GURL url_;
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
   base::Time expiration_time_;
   bool secure_;
   bool http_only_;
   bool first_party_only_;
+  bool enforce_prefixes_;
   CookiePriority priority_;
   SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCookieWithDetailsTask);
 };
 
 void CookieMonster::SetCookieWithDetailsTask::Run() {
   bool success = this->cookie_monster()->SetCookieWithDetails(
       url_, name_, value_, domain_, path_, expiration_time_, secure_,
-      http_only_, first_party_only_, priority_);
+      http_only_, first_party_only_, enforce_prefixes_, priority_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&SetCookiesCallback::Run,
                                     base::Unretained(&callback_), success));
   }
 }
 
 // Task class for GetAllCookies call.
 class CookieMonster::GetAllCookiesTask : public CookieMonsterTask {
  public:
   GetAllCookiesTask(CookieMonster* cookie_monster,
@@ skipping 428 matching lines @@
 void CookieMonster::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     const Time& expiration_time,
     bool secure,
     bool http_only,
     bool first_party_only,
+    bool enforce_prefixes,
     CookiePriority priority,
     const SetCookiesCallback& callback) {
   scoped_refptr<SetCookieWithDetailsTask> task = new SetCookieWithDetailsTask(
       this, url, name, value, domain, path, expiration_time, secure, http_only,
-      first_party_only, priority, callback);
+      first_party_only, enforce_prefixes, priority, callback);
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   scoped_refptr<GetAllCookiesTask> task = new GetAllCookiesTask(this, callback);
 
   DoCookieTask(task);
 }
 
 void CookieMonster::GetAllCookiesForURLWithOptionsAsync(
@@ skipping 159 matching lines @@
 
 bool CookieMonster::SetCookieWithDetails(const GURL& url,
                                          const std::string& name,
                                          const std::string& value,
                                          const std::string& domain,
                                          const std::string& path,
                                          const base::Time& expiration_time,
                                          bool secure,
                                          bool http_only,
                                          bool first_party_only,
+                                         bool enforce_prefixes,
                                          CookiePriority priority) {
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
   Time creation_time = CurrentTime();
   last_time_seen_ = creation_time;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(url, name, value, domain, path,
                                    creation_time, expiration_time, secure,
                                    http_only, first_party_only, priority));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   options.set_include_first_party_only();
+  if (enforce_prefixes)
+    options.set_enforce_prefixes();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::ImportCookies(const CookieList& list) {
   base::AutoLock autolock(lock_);
   MarkCookieStoreAsInitialized();
   if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
     FetchAllCookiesIfNecessary();
   for (CookieList::const_iterator iter = list.begin(); iter != list.end();
        ++iter) {
@@ skipping 736 matching lines @@
   }
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                                        const Time& creation_time,
                                        const CookieOptions& options) {
   const std::string key(GetKey((*cc)->Domain()));
   bool already_expired = (*cc)->IsExpired(creation_time);
 
+  if (options.enforce_prefixes() && !CheckCookiePrefix(cc->get(), options)) {
+    VLOG(kVlogSetCookies) << "SetCookie() not storing cookie '" << (*cc)->Name()
+                          << "' that violates prefix rules.";
+    return false;
+  }
+
   if (DeleteAnyEquivalentCookie(key, **cc, options.exclude_httponly(),
                                 already_expired)) {
     VLOG(kVlogSetCookies) << "SetCookie() not clobbering httponly cookie";
     return false;
   }
 
   VLOG(kVlogSetCookies) << "SetCookie() key: " << key
                         << " cc: " << (*cc)->DebugString();
 
   // Realize that we might be setting an expired cookie, and the only point
@@ skipping 454 matching lines @@
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, removed);
     }
   }
 }
 
 }  // namespace net