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 <CommonCrypto/CommonCryptor.h>
 #include <CoreFoundation/CFString.h>
 #include <Security/cssm.h>
 
@@ skipping 14 matching lines @@
     // 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) {
+uint8_t* 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) {
+  if (err != CSSM_OK) {

[wtc, 2011/05/17 23:37:52]

Although I prefer this form, it's more important to be
consistent.  So I prefer we not change this, or we should
change all instances of
  if (err)
in this file.

[Denis Lagno, 2011/05/18 11:53:32]

Done.

     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
+  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
 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);
+  size_t key_size_in_bytes = (key_size_in_bits + 7) / 8;
+  uint8_t* random_bytes = CreateRandomBytes(key_size_in_bytes);
   if (!random_bytes)
     return NULL;
   SymmetricKey *key = new SymmetricKey(random_bytes, key_size_in_bits);
+  std::fill(random_bytes, random_bytes + key_size_in_bytes, 0);

[wtc, 2011/05/17 23:37:52]

You can use
  memset(random_bytes, 0, key_size_in_bytes);
here instead.  Then you don't need to change CreateRandomBytes
to return uint8_t*.

[Denis Lagno, 2011/05/18 11:53:32]

better leave std::fill for consistency

   free(random_bytes);
   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) {
@@ skipping 44 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) {

[wtc, 2011/05/17 23:37:52]

I was told to use reinterpret_cast to cast void* to foo*.
I don't remember why, but it may be the recommendations
of the Style Guide:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Casting

So I prefer that we not change this cast.

[Denis Lagno, 2011/05/18 11:53:32]

Done.

+}
 
 bool SymmetricKey::GetRawKey(std::string* raw_key) {
   *raw_key = key_;
   return true;
 }
 
 CSSM_DATA SymmetricKey::cssm_data() const {
   return StringToData(key_);
 }
 
 }  // namespace crypto