Implement RSAPrivateKey::Copy()

crypto/rsa_private_key_mac.cc

Index: crypto/rsa_private_key_mac.cc
diff --git a/crypto/rsa_private_key_mac.cc b/crypto/rsa_private_key_mac.cc
index 85dadfa9ee67fe4df267514d845a48e2c4f9cd60..61ff7200e6a48bc5c25c4b1806f1de0b297559ba 100644
--- a/crypto/rsa_private_key_mac.cc
+++ b/crypto/rsa_private_key_mac.cc
@@ -10,6 +10,23 @@
 #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
@@ -174,13 +191,22 @@ RSAPrivateKey::~RSAPrivateKey() {
   }
 }
 
+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;
 }