Private API for extensions like ssh-client that need access to TCP.

crypto/symmetric_key_mac.cc

 // Copyright (c) 2011 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 "crypto/symmetric_key.h"
 
+#include <vector>
+
 #include <CommonCrypto/CommonCryptor.h>
 #include <CoreFoundation/CFString.h>
 #include <Security/cssm.h>
 
 #include "base/logging.h"
 #include "crypto/cssm_init.h"
 
 namespace {
 
 CSSM_KEY_TYPE CheckKeyParams(crypto::SymmetricKey::Algorithm algorithm,
                              size_t key_size_in_bits) {
   if (algorithm == crypto::SymmetricKey::AES) {
     CHECK(key_size_in_bits == 128 ||
         key_size_in_bits == 192 ||
         key_size_in_bits == 256)
         << "Invalid key size " << key_size_in_bits << " bits";
     return CSSM_ALGID_AES;
   } else {
     // FIPS 198 Section 3 requires a HMAC-SHA-1 derived keys to be at least
     // (HMAC-SHA-1 output size / 2) to be compliant. Since the ouput size of
     // HMAC-SHA-1 is 160 bits, we require at least 80 bits here.
     CHECK(algorithm == crypto::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(crypto::GetSharedCSPHandle(),
-                                        CSSM_ALGID_APPLE_YARROW,
-                                        NULL,
-                                        size, &ctx);
-  if (err) {
-    crypto::LogCSSMError("CSSM_CSP_CreateRandomGenContext", err);
-    return NULL;
-  }
-  CSSM_DATA random_data = {};
-  err = CSSM_GenerateRandom(ctx, &random_data);
-  if (err) {
-    crypto::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 crypto {
 
-SymmetricKey::~SymmetricKey() {}
+SymmetricKey::~SymmetricKey() {
+  std::fill(key_.begin(), key_.end(), 0);
+}
+
+// static
+bool SymmetricKey::GenerateRandomBytes(size_t num_bytes, uint8* out) {
+  if (num_bytes == 0)
+    return true;
+  if (out == NULL)
+    return false;
+
+  CSSM_RETURN err;
+  CSSM_CC_HANDLE ctx;
+  err = CSSM_CSP_CreateRandomGenContext(crypto::GetSharedCSPHandle(),
+                                        CSSM_ALGID_APPLE_YARROW,
+                                        NULL,
+                                        num_bytes, &ctx);
+  if (err) {
+    crypto::LogCSSMError("CSSM_CSP_CreateRandomGenContext", err);
+    return false;
+  }
+  CSSM_DATA random_data = { num_bytes, out };
+  err = CSSM_GenerateRandom(ctx, &random_data);
+  CSSM_DeleteContext(ctx);
+  if (err != CSSM_OK) {
+    crypto::LogCSSMError("CSSM_GenerateRandom", err);
+    return false;
+  }
+  DCHECK(random_data.Data == out);
+  return true;
+}
 
 // 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)
+  std::vector<uint8> random_bytes((key_size_in_bits + 7) / 8);
+  if (!GenerateRandomBytes(random_bytes.size(), &random_bytes[0]))
     return NULL;
-  SymmetricKey *key = new SymmetricKey(random_bytes, key_size_in_bits);
-  free(random_bytes);
+  SymmetricKey* key = new SymmetricKey(&random_bytes[0], key_size_in_bits);
+  std::fill(random_bytes.begin(), random_bytes.end(), 0u);
   return key;
 }
 
 // static
 SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
                                                   const std::string& password,
                                                   const std::string& salt,
                                                   size_t iterations,
                                                   size_t key_size_in_bits) {
   // Derived (haha) from cdsaDeriveKey() in Apple's CryptoSample.
@@ skipping 43 matching lines @@
   CSSM_FreeKey(GetSharedCSPHandle(), &credentials, &cssm_key, false);
   return derived_key;
 }
 
 // static
 SymmetricKey* SymmetricKey::Import(Algorithm algorithm,
                                    const std::string& raw_key) {
   return new SymmetricKey(raw_key.data(), raw_key.size() * 8);
 }
 
-SymmetricKey::SymmetricKey(const void *key_data, size_t key_size_in_bits)
-  : key_(reinterpret_cast<const char*>(key_data),
-         key_size_in_bits / 8) {}
+SymmetricKey::SymmetricKey(const void* key_data, size_t key_size_in_bits)
+    : key_(static_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 crypto