Implement RSAPrivateKey::Copy()

crypto/rsa_private_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/rsa_private_key.h"
 
 #include <list>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "crypto/cssm_init.h"
 
+namespace {
+
+bool CopyCssmKey(const CSSM_KEY& source, CSSM_KEY* destination) {

[wtc, 2011/11/30 00:58:10]

Nit: CopyCssmKey => CopyCSSMKey

rsleevi: is there a CSSM function for copying a CSSM_KEY?

[Ryan Sleevi, 2011/11/30 02:05:09]

No.

Further, it's not necessarily safe to copy KeyData here. According to the
CDSA/CSSM Version 2 spec, KeyData is CSP-specific and applications should not
rely on any particular behaviour.

The salient details are conveyed in C.2.1.1/C.2.1.2 (Key Formats & References)
and C.4 (Memory Management), of the "Cryptographic Service Provider Behaviour"
Appendix.

This is why I used SecKeyRef for the NSS client-side SSL patches - it exposed a
sane refcounting API.

You could potentially use Wrap and Unwrap operations, but that may not work if
the key isn't extractable. The "correct" behaviour (read: 500+ lines of code,
IIRC) is to search through the DLDB for the key if/when you need it. Not fun.

Unfortunately, I don't have any good recommendations/suggestions for how to
implement this on the CDSA/CSSM side.

That said, putting on the "But we only use Security.framework" hat, there is the
private API SecKeyCreateWithCSSMKey(), which does effectively cheat and dupe the
CSSM_KEY. 

You have to be careful though - if a caller does CSSM_FreeKey, they could free
the reference (stored in .Data) that is backing your key. Bad things can happen
- which is why that API is private.

[Sergey Ulanov, 2011/11/30 22:30:03]

Removed this function

+  destination->KeyHeader = source.KeyHeader;
+  destination->KeyData.Length = source.KeyData.Length;
+  destination->KeyData.Data =
+      reinterpret_cast<uint8*>(crypto::CSSMMalloc(source.KeyData.Length));
+  if (!destination->KeyData.Data) {
+    NOTREACHED() << "CSSMMalloc failed";
+    return false;
+  }
+  memcpy(destination->KeyData.Data, source.KeyData.Data, source.KeyData.Length);
+  return true;
+}
+
+} // namespace
+
 namespace crypto {
 
 // static
 RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) {
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey);
 
   CSSM_CC_HANDLE cc_handle;
   CSSM_RETURN crtn;
   crtn = CSSM_CSP_CreateKeyGenContext(GetSharedCSPHandle(), CSSM_ALGID_RSA,
                                       num_bits, NULL, NULL, NULL, NULL, NULL,
@@ skipping 144 matching lines @@
 
 RSAPrivateKey::~RSAPrivateKey() {
   if (key_.KeyData.Data) {
     CSSM_FreeKey(GetSharedCSPHandle(), NULL, &key_, CSSM_FALSE);
   }
   if (public_key_.KeyData.Data) {
     CSSM_FreeKey(GetSharedCSPHandle(), NULL, &public_key_, CSSM_FALSE);
   }
 }
 
+RSAPrivateKey* RSAPrivateKey::Copy() const {
+  scoped_ptr<RSAPrivateKey> copy(new RSAPrivateKey());
+  if (!CopyCssmKey(key_, &copy->key_) ||
+      !CopyCssmKey(public_key_, &copy->public_key_)) {
+    return NULL;
+  }
+  return copy.release();
+}
+
 bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) {
   if (!key_.KeyData.Data || !key_.KeyData.Length) {
     return false;
   }
   output->clear();
   output->insert(output->end(), key_.KeyData.Data,
-                key_.KeyData.Data + key_.KeyData.Length);
+                 key_.KeyData.Data + key_.KeyData.Length);
   return true;
 }
 
 bool RSAPrivateKey::ExportPublicKey(std::vector<uint8>* output) {
   PrivateKeyInfoCodec private_key_info(true);
   std::vector<uint8> private_key_data;
   private_key_data.assign(key_.KeyData.Data,
                           key_.KeyData.Data + key_.KeyData.Length);
   return (private_key_info.Import(private_key_data) &&
           private_key_info.ExportPublicKeyInfo(output));
 }
 
 }  // namespace crypto