components/os_crypt/os_crypt_mac.mm

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/os_crypt/os_crypt.h"
   6
   7 #include <CommonCrypto/CommonCryptor.h>  // for kCCBlockSizeAES128
   8
   9 #include "base/command_line.h"
  10 #include "base/debug/leak_annotations.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/synchronization/lock.h"
  15 #include "components/os_crypt/keychain_password_mac.h"
  16 #include "components/os_crypt/os_crypt_switches.h"
  17 #include "crypto/apple_keychain.h"
  18 #include "crypto/encryptor.h"
  19 #include "crypto/mock_apple_keychain.h"
  20 #include "crypto/symmetric_key.h"
  21
  22 using crypto::AppleKeychain;
  23
  24 namespace {
  25
  26 // Salt for Symmetric key derivation.
  27 const char kSalt[] = "saltysalt";
  28
  29 // Key size required for 128 bit AES.
  30 const size_t kDerivedKeySizeInBits = 128;
  31
  32 // Constant for Symmetic key derivation.
  33 const size_t kEncryptionIterations = 1003;
  34
  35 // TODO(dhollowa): Refactor to allow dependency injection of Keychain.
  36 static bool use_mock_keychain = false;
  37
  38 // Prefix for cypher text returned by current encryption version.  We prefix
  39 // the cypher text with this string so that future data migration can detect
  40 // this and migrate to different encryption without data loss.
  41 const char kEncryptionVersionPrefix[] = "v10";
  42
  43 // Generates a newly allocated SymmetricKey object based on the password found
  44 // in the Keychain.  The generated key is for AES encryption.  Returns NULL key
  45 // in the case password access is denied or key generation error occurs.
  46 crypto::SymmetricKey* GetEncryptionKey() {
  47   static crypto::SymmetricKey* cached_encryption_key = NULL;
  48   static bool key_is_cached = false;
  49   static base::Lock lock;
  50   base::AutoLock auto_lock(lock);
  51
  52   if (key_is_cached)
  53     return cached_encryption_key;
  54
  55   static bool mock_keychain_command_line_flag =
  56       base::CommandLine::ForCurrentProcess()->HasSwitch(
  57           os_crypt::switches::kUseMockKeychain);
  58
  59   std::string password;
  60   if (use_mock_keychain || mock_keychain_command_line_flag) {
  61     crypto::MockAppleKeychain keychain;
  62     password = keychain.GetEncryptionPassword();
  63   } else {
  64     AppleKeychain keychain;
  65     KeychainPassword encryptor_password(keychain);
  66     password = encryptor_password.GetPassword();
  67   }
  68
  69   // Subsequent code must guarantee that the correct key is cached before
  70   // returning.
  71   key_is_cached = true;
  72
  73   if (password.empty())
  74     return cached_encryption_key;
  75
  76   std::string salt(kSalt);
  77
  78   // Create an encryption key from our password and salt. The key is
  79   // intentionally leaked.
  80   cached_encryption_key =
  81       crypto::SymmetricKey::DeriveKeyFromPassword(crypto::SymmetricKey::AES,
  82                                                   password,
  83                                                   salt,
  84                                                   kEncryptionIterations,
  85                                                   kDerivedKeySizeInBits);
  86   ANNOTATE_LEAKING_OBJECT_PTR(cached_encryption_key);
  87   DCHECK(cached_encryption_key);
  88   return cached_encryption_key;
  89 }
  90
  91 }  // namespace
  92
  93 bool OSCrypt::EncryptString16(const base::string16& plaintext,
  94                               std::string* ciphertext) {
  95   return EncryptString(base::UTF16ToUTF8(plaintext), ciphertext);
  96 }
  97
  98 bool OSCrypt::DecryptString16(const std::string& ciphertext,
  99                               base::string16* plaintext) {
 100   std::string utf8;
 101   if (!DecryptString(ciphertext, &utf8))
 102     return false;
 103
 104   *plaintext = base::UTF8ToUTF16(utf8);
 105   return true;
 106 }
 107
 108 bool OSCrypt::EncryptString(const std::string& plaintext,
 109                             std::string* ciphertext) {
 110   if (plaintext.empty()) {
 111     *ciphertext = std::string();
 112     return true;
 113   }
 114
 115   crypto::SymmetricKey* encryption_key = GetEncryptionKey();
 116   if (!encryption_key)
 117     return false;
 118
 119   std::string iv(kCCBlockSizeAES128, ' ');
 120   crypto::Encryptor encryptor;
 121   if (!encryptor.Init(encryption_key, crypto::Encryptor::CBC, iv))
 122     return false;
 123
 124   if (!encryptor.Encrypt(plaintext, ciphertext))
 125     return false;
 126
 127   // Prefix the cypher text with version information.
 128   ciphertext->insert(0, kEncryptionVersionPrefix);
 129   return true;
 130 }
 131
 132 bool OSCrypt::DecryptString(const std::string& ciphertext,
 133                             std::string* plaintext) {
 134   if (ciphertext.empty()) {
 135     *plaintext = std::string();
 136     return true;
 137   }
 138
 139   // Check that the incoming cyphertext was indeed encrypted with the expected
 140   // version.  If the prefix is not found then we'll assume we're dealing with
 141   // old data saved as clear text and we'll return it directly.
 142   // Credit card numbers are current legacy data, so false match with prefix
 143   // won't happen.
 144   if (ciphertext.find(kEncryptionVersionPrefix) != 0) {
 145     *plaintext = ciphertext;
 146     return true;
 147   }
 148
 149   // Strip off the versioning prefix before decrypting.
 150   std::string raw_ciphertext =
 151       ciphertext.substr(strlen(kEncryptionVersionPrefix));
 152
 153   crypto::SymmetricKey* encryption_key = GetEncryptionKey();
 154   if (!encryption_key)
 155     return false;
 156
 157   std::string iv(kCCBlockSizeAES128, ' ');
 158   crypto::Encryptor encryptor;
 159   if (!encryptor.Init(encryption_key, crypto::Encryptor::CBC, iv))
 160     return false;
 161
 162   if (!encryptor.Decrypt(raw_ciphertext, plaintext))
 163     return false;
 164
 165   return true;
 166 }
 167
 168 void OSCrypt::UseMockKeychain(bool use_mock) {
 169   use_mock_keychain = use_mock;
 170 }
 171