Implement PBKDF2-based key derivation, random key generation,...

base/crypto/symmetric_key_mac.cc

 // Copyright (c) 2010 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 "base/crypto/symmetric_key.h"
 
 #include <CommonCrypto/CommonCryptor.h>
 #include <CoreFoundation/CFString.h>
 #include <Security/cssm.h>
 
@@ skipping 11 matching lines @@
         key_size_in_bits == 256)
         << "Invalid key size " << key_size_in_bits << " bits";
     return CSSM_ALGID_AES;
   } else {
     CHECK(algorithm == base::SymmetricKey::HMAC_SHA1);
     CHECK(key_size_in_bits >= 80 && (key_size_in_bits % 8) == 0)
         << "Invalid key size " << key_size_in_bits << " bits";
     return CSSM_ALGID_SHA1HMAC_LEGACY;
   }
 }
-  
+
 void* CreateRandomBytes(size_t size) {
   CSSM_RETURN err;
   CSSM_CC_HANDLE ctx;
   err = CSSM_CSP_CreateRandomGenContext(base::GetSharedCSPHandle(),
                                         CSSM_ALGID_APPLE_YARROW,
                                         NULL,
                                         size, &ctx);
   if (err) {
     base::LogCSSMError("CSSM_CSP_CreateRandomGenContext", err);
     return NULL;
   }
   CSSM_DATA random_data = {};
   err = CSSM_GenerateRandom(ctx, &random_data);
   if (err) {
     base::LogCSSMError("CSSM_GenerateRandom", err);
     random_data.Data = NULL;
   }
   CSSM_DeleteContext(ctx);
   return random_data.Data;  // Caller responsible for freeing this
-}  
-  
+}
+
 inline CSSM_DATA StringToData(const std::string& str) {
   CSSM_DATA data = {
     str.size(),
     reinterpret_cast<uint8_t*>(const_cast<char*>(str.data()))
   };
   return data;
 }
 
 }  // namespace
 
 namespace base {
 
+SymmetricKey::~SymmetricKey() {}
+
 // static
 SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
                                               size_t key_size_in_bits) {
   CheckKeyParams(algorithm, key_size_in_bits);
   void* random_bytes = CreateRandomBytes((key_size_in_bits + 7) / 8);
   if (!random_bytes)
     return NULL;
   SymmetricKey *key = new SymmetricKey(random_bytes, key_size_in_bits);
   free(random_bytes);
   return key;
@@ skipping 40 matching lines @@
                        NULL,
                        &cssm_key);
   if (err) {
     LogCSSMError("CSSM_DeriveKey", err);
     goto exit;
   }
 
   DCHECK_EQ(cssm_key.KeyData.Length, key_size_in_bits / 8);
   derived_key = new SymmetricKey(cssm_key.KeyData.Data, key_size_in_bits);
 
-exit:
+ exit:
   CSSM_DeleteContext(ctx);
   CSSM_FreeKey(GetSharedCSPHandle(), &credentials, &cssm_key, false);
   return derived_key;
 }
 
 SymmetricKey::SymmetricKey(const void *key_data, size_t key_size_in_bits)
   : key_(reinterpret_cast<const char*>(key_data),
          key_size_in_bits / 8) {}
 
 bool SymmetricKey::GetRawKey(std::string* raw_key) {
   *raw_key = key_;
   return true;
 }
 
 CSSM_DATA SymmetricKey::cssm_data() const {
   return StringToData(key_);
 }
 
 }  // namespace base