Thread safe initialization of OSCrypt cache

components/os_crypt/os_crypt_linux.cc

 // Copyright 2016 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 "components/os_crypt/os_crypt.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
 #include <memory>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/lock.h"
 #include "components/os_crypt/key_storage_linux.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 
 namespace {
 
 // Salt for Symmetric key derivation.
 const char kSalt[] = "saltysalt";
 
 // Key size required for 128 bit AES.
@@ skipping 20 matching lines @@
 const char kObfuscationPrefix[][4] = {
     "v10", "v11",
 };
 
 struct Cache {
   std::unique_ptr<KeyStorageLinux> key_storage_cache;
   std::unique_ptr<std::string> password_v10_cache;
   std::unique_ptr<std::string> password_v11_cache;
   bool is_key_storage_cached;
   bool is_password_v11_cached;
+  // Guards access to |g_cache|, making lazy initialization of individual parts
+  // thread safe.
+  base::Lock lock;
 };
 
 base::LazyInstance<Cache>::Leaky g_cache = LAZY_INSTANCE_INITIALIZER;
 
 // Lazy acquisition and caching of a KeyStorage. Will be null if no service is
 // found.
 KeyStorageLinux* GetKeyStorage() {
   if (!g_cache.Get().is_key_storage_cached) {
     g_cache.Get().is_key_storage_cached = true;
     g_cache.Get().key_storage_cache = KeyStorageLinux::CreateService();
   }
   return g_cache.Get().key_storage_cache.get();
 }
 
-// Returns a cached string of "peanuts".
+// Returns a cached string of "peanuts". Is thread-safe.
 std::string* GetPasswordV10() {
-  if (!g_cache.Get().password_v10_cache.get())
+  base::AutoLock auto_lock(g_cache.Get().lock);
+  if (!g_cache.Get().password_v10_cache.get()) {
     g_cache.Get().password_v10_cache.reset(new std::string("peanuts"));
+  }
   return g_cache.Get().password_v10_cache.get();
 }
 
 // Caches and returns the password from the KeyStorage or null if there is no
-// service.
+// service. Is thread-safe.
 std::string* GetPasswordV11() {
+  base::AutoLock auto_lock(g_cache.Get().lock);
   if (!g_cache.Get().is_password_v11_cached) {
-    g_cache.Get().is_password_v11_cached = true;
     g_cache.Get().password_v11_cache.reset(
         GetKeyStorage() ? new std::string(GetKeyStorage()->GetKey()) : nullptr);
+    g_cache.Get().is_password_v11_cached = true;
   }
   return g_cache.Get().password_v11_cache.get();
 }
 
 // Pointer to a function that creates and returns the |KeyStorage| instance to
 // be used. The function maintains ownership of the pointer.
 KeyStorageLinux* (*g_key_storage_provider)() = &GetKeyStorage;
 
 // Pointers to functions that return a password for deriving the encryption key.
 // One function for each supported password version (see Version enum).
@@ skipping 146 matching lines @@
   static bool is_get_password_saved = false;
   static std::string* (*get_password_save[arraysize(g_get_password)])();
   if (!is_get_password_saved) {
     std::copy(std::begin(g_get_password), std::end(g_get_password),
               std::begin(get_password_save));
     is_get_password_saved = true;
   }
 
   if (get_key_storage_mock && get_password_v11_mock) {
     // Bypass calling KeyStorage::CreateService and caching of the key for V11
-    g_get_password[Version::V11] = get_password_v11_mock;
+    if (get_password_v11_mock)
+      g_get_password[Version::V11] = get_password_v11_mock;
     // OSCrypt will determine the encryption version by checking if a
     // |KeyStorage| instance can be created. Enable V11 by returning the mock.
-    g_key_storage_provider = get_key_storage_mock;
+    if (get_key_storage_mock)
+      g_key_storage_provider = get_key_storage_mock;
   } else {
     // Restore real implementation
     std::copy(std::begin(get_password_save), std::end(get_password_save),
               std::begin(g_get_password));
+    g_key_storage_provider = &GetKeyStorage;
   }
 }