Add ability to create self signed certs to mac.

base/crypto/rsa_private_key_mac.cc

 // Copyright (c) 2009 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/rsa_private_key.h"
 
 #include <list>
 
 #include "base/crypto/cssm_init.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
     return NULL;
   }
 
   CSSM_KEY public_key;
   memset(&public_key, 0, sizeof(CSSM_KEY));
   CSSM_DATA label = { 9,
       const_cast<uint8*>(reinterpret_cast<const uint8*>("temp_key")) };
   crtn = CSSM_GenerateKeyPair(cc_handle,
       CSSM_KEYUSE_VERIFY,
       CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_EXTRACTABLE, &label,
-      &public_key, CSSM_KEYUSE_SIGN,
+      result->public_key(), CSSM_KEYUSE_SIGN,
       CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_EXTRACTABLE, &label, NULL,
       result->key());
   CSSM_DeleteContext(cc_handle);
   if (crtn) {
     NOTREACHED() << "CSSM_CSP_CreateKeyGenContext failed: " << crtn;
     return NULL;
   }
 
-  // Public key is not needed.
-  CSSM_FreeKey(GetSharedCSPHandle(), NULL, &public_key, CSSM_FALSE);
-
   return result.release();
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateSensitive(uint16 num_bits) {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 // static
@@ skipping 66 matching lines @@
 }
 
 RSAPrivateKey::RSAPrivateKey() {
   memset(&key_, 0, sizeof(key_));
 
   EnsureCSSMInit();
 }
 
 RSAPrivateKey::~RSAPrivateKey() {
   if (key_.KeyData.Data) {
-    CSSM_FreeKey(GetSharedCSPHandle(), NULL, &key_, CSSM_FALSE);
+    CSSM_CSP_HANDLE csp_handle = GetSharedCSPHandle();
+    CSSM_FreeKey(csp_handle, NULL, &key_, CSSM_FALSE);
+    CSSM_FreeKey(csp_handle, NULL, &public_key_, CSSM_FALSE);
   }
 }
 
 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);
   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));
+  if (!public_key_.KeyData.Data || !public_key_.KeyData.Length) {
+    return false;
+  }
+  output->clear();
+  output->insert(output->end(), public_key_.KeyData.Data,
+                 public_key_.KeyData.Data + public_key_.KeyData.Length);
+  return true;
 }
 
 }  // namespace base