Implement symmetric key for openssl

base/crypto/symmetric_key_openssl.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 <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/rand.h>
+
 #include "base/logging.h"
+#include "base/scoped_ptr.h"
+#include "base/stl_util-inl.h"
 
 namespace base {
 
+SymmetricKey::SymmetricKey(std::string* key) {
+  key->swap(key_);

[Ryan Sleevi, 2010/11/10 23:18:46]

Why the swap, as opposed to assignment or just taking a const reference and
copying? You copy anyways with Import(), so I can't imagine for optimization.

Just wondering.

[joth, 2010/11/11 15:07:12]

Just trying to reduce the number of copies of the confidential |key| left lying
around in memory. Only doing it this way as the c'tor is private, so this is all
an internal detail.

+}
+
 SymmetricKey::~SymmetricKey() {
+  // Zero out the content.
+  key_.assign(key_.length(), '\0');
 }
 
 // static
 SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
                                               size_t key_size_in_bits) {
-  NOTIMPLEMENTED();
-  return NULL;
+  DCHECK_EQ(AES, algorithm);

[Ryan Sleevi, 2010/11/10 23:18:46]

Why restrict |algorithm| to AES? See symmetric_key_mac.cc's CheckKeyParams() for
a comparable implementation that will generate random data of sufficient length.

[joth, 2010/11/11 15:07:12]

Just copied this from the NSS version, I didn't want to deviate from its API
more than necessary.

+  int key_size_in_bytes = key_size_in_bits / 8;

[Ryan Sleevi, 2010/11/10 23:18:46]

My bit-byte sense tingles on this, though it may be a false alarm. For paranoia
sake, perhaps:

int key_size_in_bytes = (key_size_in_bits + 7) / 8;

See also symmetric_key_mac.cc GenerateRandomKey(), although it appears the rest
of that file remains inconsistent and alternates with just / 8.

Also on line 57

[joth, 2010/11/11 15:07:12]

As above, although I originally had a CHECK that the remainder was 0, which I
prefer to trying to second guess the best handling of it.
I'll put that back in.

+
+  if (key_size_in_bits == 0)
+    return NULL;
+
+  std::string key;
+  key.resize(key_size_in_bytes);
+
+  unsigned char* key_data =
+      reinterpret_cast<unsigned char*>(string_as_array(&key));
+  int res = RAND_bytes(key_data, key.length());
+  if (res != 1) {
+    unsigned long err = ERR_get_error();

[Ryan Sleevi, 2010/11/10 23:18:46]

As a defensive measure, whenever programming OpenSSL, I try to drain the entire
OpenSSL error queue on an error. Not doing so has lead to real bugs in the past
(eg: CVE-2008-1531 http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-1531 )

[joth, 2010/11/11 15:07:12]

Done.

+    LOG(ERROR) << "Could not obtain random bytes. res = " << res
+               << ", err = " << err << " " << ERR_error_string(err, NULL);
+    return NULL;
+  }
+  return new SymmetricKey(&key);
+
 }
 
 // static
 SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
                                                   const std::string& password,
                                                   const std::string& salt,
                                                   size_t iterations,
                                                   size_t key_size_in_bits) {
-  NOTIMPLEMENTED();
-  return NULL;
+  DCHECK(algorithm == AES || algorithm == HMAC_SHA1);
+  int key_size_in_bytes = key_size_in_bits / 8;
+
+  std::string key;
+  key.resize(key_size_in_bytes);
+
+  const unsigned char* salt_data =
+      reinterpret_cast<const unsigned char*>(salt.data());
+  unsigned char* key_data =
+      reinterpret_cast<unsigned char*>(string_as_array(&key));
+
+  int res = PKCS5_PBKDF2_HMAC_SHA1(password.data(), password.length(),
+                                   salt_data, salt.length(), iterations,
+                                   key.length(), key_data);
+  if (res != 1) {
+    NOTREACHED() << "HMAC SHA1 failed. res = " << res;
+    return NULL;
+  }
+  return new SymmetricKey(&key);
 }
 
 // static
 SymmetricKey* SymmetricKey::Import(Algorithm algorithm,
                                    const std::string& raw_key) {
-  NOTIMPLEMENTED();
-  return NULL;
+  std::string copy(raw_key);
+  return new SymmetricKey(&copy);
 }
 
 bool SymmetricKey::GetRawKey(std::string* raw_key) {
-  NOTIMPLEMENTED();
-  return false;
+  *raw_key = key_;
+  return true;
 }
 
 }  // namespace base