[CacheStorage] Pad and bin opaque resource sizes.

content/browser/cache_storage/cache_storage.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/guid.h"
+#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_index.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
+#include "crypto/symmetric_key.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
+using base::LazyInstance;
+using crypto::SymmetricKey;
+
 namespace content {
 
 namespace {
 
+const SymmetricKey::Algorithm kPaddingKeyAlgorithm = SymmetricKey::AES;
+
+// LazyInstance needs a new-able type so this class exists solely to "own"
+// a SymmetricKey.
+class SymmetricKeyOwner {
+ public:
+  std::unique_ptr<SymmetricKey> CreateDuplicate() const {
+    return SymmetricKey::Import(kPaddingKeyAlgorithm, key());
+  }
+
+  // Only for test purposes.
+  void GenerateNew() {
+    key_ = SymmetricKey::GenerateRandomKey(kPaddingKeyAlgorithm, 128);
+  }
+
+  const std::string& key() const { return key_->key(); }
+
+ private:
+  std::unique_ptr<SymmetricKey> key_ =
+      SymmetricKey::GenerateRandomKey(kPaddingKeyAlgorithm, 128);
+};
+
+static LazyInstance<SymmetricKeyOwner>::Leaky s_padding_key =
+    LAZY_INSTANCE_INITIALIZER;
+
 std::string HexedHash(const std::string& value) {
   std::string value_hash = base::SHA1HashString(value);
   std::string valued_hexed_hash = base::ToLowerASCII(
       base::HexEncode(value_hash.c_str(), value_hash.length()));
   return valued_hexed_hash;
 }
 
 void SizeRetrievedFromAllCaches(std::unique_ptr<int64_t> accumulator,
                                 CacheStorage::SizeCallback callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(std::move(callback), *accumulator));
 }
 
 void DoNothingWithBool(bool success) {}
 
+std::unique_ptr<SymmetricKey> ImportPaddingKey(const std::string& raw_key) {
+  return SymmetricKey::Import(kPaddingKeyAlgorithm, raw_key);
+}
+
 }  // namespace
 
 const char CacheStorage::kIndexFileName[] = "index.txt";
 constexpr int64_t CacheStorage::kSizeUnknown;
 
 struct CacheStorage::CacheMatchResponse {
   CacheMatchResponse() = default;
   ~CacheMatchResponse() = default;
 
   CacheStorageError error;
@@ skipping 25 matching lines @@
         origin_(origin) {
     DCHECK(!origin_.is_empty());
   }
 
   virtual ~CacheLoader() {}
 
   // Creates a CacheStorageCache with the given name. It does not attempt to
   // load the backend, that happens lazily when the cache is used.
   virtual std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name,
-      int64_t cache_size) = 0;
+      int64_t cache_size,
+      int64_t cache_padding,
+      std::unique_ptr<SymmetricKey> cache_padding_key) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
   virtual void PrepareNewCacheDestination(const std::string& cache_name,
                                           CacheCallback callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
   virtual void CleanUpDeletedCache(CacheStorageCache* cache) = 0;
 
   // Writes the cache index to disk if applicable.
@@ skipping 41 matching lines @@
                base::WeakPtr<storage::BlobStorageContext> blob_context,
                CacheStorage* cache_storage,
                const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
                     cache_storage,
                     origin) {}
 
-  std::unique_ptr<CacheStorageCache> CreateCache(const std::string& cache_name,
-                                                 int64_t cache_size) override {
+  std::unique_ptr<CacheStorageCache> CreateCache(
+      const std::string& cache_name,
+      int64_t cache_size,
+      int64_t cache_padding,
+      std::unique_ptr<SymmetricKey> cache_padding_key) override {
     return CacheStorageCache::CreateMemoryCache(
         origin_, cache_name, cache_storage_, request_context_getter_,
-        quota_manager_proxy_, blob_context_);
+        quota_manager_proxy_, blob_context_,
+        s_padding_key.Get().CreateDuplicate());
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   CacheCallback callback) override {
     std::unique_ptr<CacheStorageCache> cache =
-        CreateCache(cache_name, 0 /*cache_size*/);
+        CreateCache(cache_name, 0 /*cache_size*/, 0 /* cache_padding */,
+                    s_padding_key.Get().CreateDuplicate());
     std::move(callback).Run(std::move(cache));
   }
 
   void CleanUpDeletedCache(CacheStorageCache* cache) override {}
 
   void WriteIndex(const CacheStorageIndex& index,
                   BoolCallback callback) override {
     std::move(callback).Run(true);
   }
 
@@ skipping 37 matching lines @@
                     const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
                     cache_storage,
                     origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
-  std::unique_ptr<CacheStorageCache> CreateCache(const std::string& cache_name,
-                                                 int64_t cache_size) override {
+  std::unique_ptr<CacheStorageCache> CreateCache(
+      const std::string& cache_name,
+      int64_t cache_size,
+      int64_t cache_padding,
+      std::unique_ptr<SymmetricKey> cache_padding_key) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_name));
 
     std::string cache_dir = cache_name_to_cache_dir_[cache_name];
     base::FilePath cache_path = origin_path_.AppendASCII(cache_dir);
     return CacheStorageCache::CreatePersistentCache(
         origin_, cache_name, cache_storage_, cache_path,
         request_context_getter_, quota_manager_proxy_, blob_context_,
-        cache_size);
+        cache_size, cache_padding, std::move(cache_padding_key));
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   CacheCallback callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     PostTaskAndReplyWithResult(
         cache_task_runner_.get(), FROM_HERE,
         base::BindOnce(&SimpleCacheLoader::PrepareNewCacheDirectoryInPool,
                        origin_path_),
@@ skipping 17 matching lines @@
 
   void PrepareNewCacheCreateCache(const std::string& cache_name,
                                   CacheCallback callback,
                                   const std::string& cache_dir) {
     if (cache_dir.empty()) {
       std::move(callback).Run(std::unique_ptr<CacheStorageCache>());
       return;
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
-    std::move(callback).Run(
-        CreateCache(cache_name, CacheStorage::kSizeUnknown));
+    std::move(callback).Run(CreateCache(cache_name, CacheStorage::kSizeUnknown,
+                                        CacheStorage::kSizeUnknown,
+                                        s_padding_key.Get().CreateDuplicate()));
   }
 
   void CleanUpDeletedCache(CacheStorageCache* cache) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(base::ContainsKey(doomed_cache_to_path_, cache));
 
     base::FilePath cache_path =
         origin_path_.AppendASCII(doomed_cache_to_path_[cache]);
     doomed_cache_to_path_.erase(cache);
 
@@ skipping 20 matching lines @@
     for (const auto& cache_metadata : index.ordered_cache_metadata()) {
       DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_metadata.name));
 
       proto::CacheStorageIndex::Cache* index_cache = protobuf_index.add_cache();
       index_cache->set_name(cache_metadata.name);
       index_cache->set_cache_dir(cache_name_to_cache_dir_[cache_metadata.name]);
       if (cache_metadata.size == CacheStorage::kSizeUnknown)
         index_cache->clear_size();
       else
         index_cache->set_size(cache_metadata.size);
+      index_cache->set_padding_key(cache_metadata.padding_key);
+      index_cache->set_padding(cache_metadata.padding);
+      index_cache->set_padding_version(
+          CacheStorageCache::GetResponsePaddingVersion());
     }
 
     std::string serialized;
     bool success = protobuf_index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path =
         origin_path_.AppendASCII(CacheStorage::kIndexFileName);
 
@@ skipping 34 matching lines @@
 
     std::unique_ptr<std::set<std::string>> cache_dirs(
         new std::set<std::string>);
 
     auto index = base::MakeUnique<CacheStorageIndex>();
     for (int i = 0, max = protobuf_index.cache_size(); i < max; ++i) {
       const proto::CacheStorageIndex::Cache& cache = protobuf_index.cache(i);
       DCHECK(cache.has_cache_dir());
       int64_t cache_size =
           cache.has_size() ? cache.size() : CacheStorage::kSizeUnknown;
-      index->Insert(CacheStorageIndex::CacheMetadata(cache.name(), cache_size));
+      int64_t cache_padding;
+      if (cache.has_padding()) {
+        if (cache.has_padding_version() &&
+            cache.padding_version() ==
+                CacheStorageCache::GetResponsePaddingVersion()) {
+          cache_padding = cache.padding();
+        } else {
+          // The padding algorithm version changed so set to unknown to force
+          // recalculation.
+          cache_padding = CacheStorage::kSizeUnknown;
+        }
+      } else {
+        cache_padding = CacheStorage::kSizeUnknown;
+      }
+
+      std::string cache_padding_key = cache.has_padding_key()
+                                          ? cache.padding_key()
+                                          : s_padding_key.Get().key();
+
+      index->Insert(CacheStorageIndex::CacheMetadata(
+          cache.name(), cache_size, cache_padding,
+          std::move(cache_padding_key)));
       cache_name_to_cache_dir_[cache.name()] = cache.cache_dir();
       cache_dirs->insert(cache.cache_dir());
     }
 
     cache_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&DeleteUnreferencedCachesInPool, origin_path_,
                                   base::Passed(&cache_dirs)));
     std::move(callback).Run(std::move(index));
   }
 
@@ skipping 289 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (index_write_pending()) {
     index_write_task_.Cancel();
     WriteIndex(std::move(callback));
     return true;
   }
   std::move(callback).Run(true /* success */);
   return false;
 }
 
-void CacheStorage::CacheSizeUpdated(const CacheStorageCache* cache,
-                                    int64_t size) {
+void CacheStorage::CacheSizeUpdated(const CacheStorageCache* cache) {
   // Should not be called for doomed caches.
   DCHECK(!base::ContainsKey(doomed_caches_,
                             const_cast<CacheStorageCache*>(cache)));
-  cache_index_->SetCacheSize(cache->cache_name(), size);
+  DCHECK_NE(cache->cache_padding(), kSizeUnknown);
+  cache_index_->SetCacheSize(cache->cache_name(), cache->cache_size());
+  cache_index_->SetCachePadding(cache->cache_name(), cache->cache_padding());
   ScheduleWriteIndex();
 }
 
 void CacheStorage::StartAsyncOperationForTesting() {
   scheduler_->ScheduleOperation(base::BindOnce(&base::DoNothing));
 }
 
 void CacheStorage::CompleteAsyncOperationForTesting() {
   scheduler_->CompleteOperationAndRunNext();
 }
 
+// static
+void CacheStorage::GenerateNewKeyForTesting() {
+  s_padding_key.Get().GenerateNew();
+}
+
 // Init is run lazily so that it is called on the proper MessageLoop.
 void CacheStorage::LazyInit() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!initialized_);
 
   if (initializing_)
     return;
 
   DCHECK(!scheduler_->ScheduledOperations());
 
@@ skipping 61 matching lines @@
 
   if (!cache) {
     std::move(callback).Run(std::unique_ptr<CacheStorageCacheHandle>(),
                             CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   CacheStorageCache* cache_ptr = cache.get();
 
   cache_map_.insert(std::make_pair(cache_name, std::move(cache)));
-  cache_index_->Insert(
-      CacheStorageIndex::CacheMetadata(cache_name, cache_ptr->cache_size()));
+  cache_index_->Insert(CacheStorageIndex::CacheMetadata(
+      cache_name, cache_ptr->cache_size(), cache_ptr->cache_padding(),
+      cache_ptr->cache_padding_key()->key()));
 
   cache_loader_->WriteIndex(
       *cache_index_,
       base::BindOnce(&CacheStorage::CreateCacheDidWriteIndex,
                      weak_factory_.GetWeakPtr(), std::move(callback),
                      base::Passed(CreateCacheHandle(cache_ptr))));
 
   cache_loader_->NotifyCacheCreated(cache_name, CreateCacheHandle(cache_ptr));
 }
 
@@ skipping 229 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   CacheMap::iterator map_iter = cache_map_.find(cache_name);
   if (map_iter == cache_map_.end())
     return std::unique_ptr<CacheStorageCacheHandle>();
 
   CacheStorageCache* cache = map_iter->second.get();
 
   if (!cache) {
+    const CacheStorageIndex::CacheMetadata* metadata =
+        cache_index_->GetMetadata(cache_name);
+    DCHECK(metadata);
     std::unique_ptr<CacheStorageCache> new_cache = cache_loader_->CreateCache(
-        cache_name, cache_index_->GetCacheSize(cache_name));
+        cache_name, metadata->size, metadata->padding,
+        ImportPaddingKey(metadata->padding_key));
     CacheStorageCache* cache_ptr = new_cache.get();
     map_iter->second = std::move(new_cache);
 
     return CreateCacheHandle(cache_ptr);
   }
 
   return CreateCacheHandle(cache);
 }
 
 void CacheStorage::SizeRetrievedFromCache(
@@ skipping 26 matching lines @@
         &CacheStorage::SizeRetrievedFromCache, weak_factory_.GetWeakPtr(),
         base::Passed(std::move(cache_handle)), barrier_closure,
         accumulator_ptr));
   }
 }
 
 void CacheStorage::SizeImpl(SizeCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
-  if (cache_index_->GetStorageSize() != kSizeUnknown) {
+  if (cache_index_->GetPaddedStorageSize() != kSizeUnknown) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::BindOnce(std::move(callback), cache_index_->GetStorageSize()));
+        FROM_HERE, base::BindOnce(std::move(callback),
+                                  cache_index_->GetPaddedStorageSize()));
     return;
   }
 
   std::unique_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::RepeatingClosure barrier_closure =
       base::BarrierClosure(cache_index_->num_entries(),
                            base::BindOnce(&SizeRetrievedFromAllCaches,
                                           base::Passed(std::move(accumulator)),
                                           std::move(callback)));
 
   for (const auto& cache_metadata : cache_index_->ordered_cache_metadata()) {
     if (cache_metadata.size != CacheStorage::kSizeUnknown) {
       *accumulator_ptr += cache_metadata.size;
       barrier_closure.Run();
       continue;
     }
     std::unique_ptr<CacheStorageCacheHandle> cache_handle =
         GetLoadedCache(cache_metadata.name);
     CacheStorageCache* cache = cache_handle->value();
     cache->Size(base::BindOnce(&CacheStorage::SizeRetrievedFromCache,
                                weak_factory_.GetWeakPtr(),
                                base::Passed(std::move(cache_handle)),
                                barrier_closure, accumulator_ptr));
   }
 }
 
 }  // namespace content