Add RSAPrivateKey::CreateFromKeypair()

crypto/rsa_private_key_nss.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 <cryptohi.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <secmod.h>
@@ skipping 63 matching lines @@
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateSensitiveFromPrivateKeyInfo(
     const std::vector<uint8>& input) {
   return CreateFromPrivateKeyInfoWithParams(input,
                                             PR_TRUE /* permanent */,
                                             PR_TRUE /* sensitive */);
 }
 
 // static
+RSAPrivateKey* RSAPrivateKey::CreateFromKeypair(
+    SECKEYPrivateKeyStr* key,
+    SECKEYPublicKeyStr* public_key) {

[Ryan Sleevi, 2013/05/07 19:45:23]

From an API perspective, there should be a little bit more error handling to
ensure it's right:

DCHECK(key);
DCHECK(public_key);

if (SECKEY_GetPrivateKeyType(public_key) != rsaKey ||
    SECKEY_GetPrivateKeyType(private_key) != rsaKey)
  return NULL;

You could also ignore |public_key| entirely and use SECKEY_ConvertToPublicKey -
which will |only| work for RSA keys (and only if the CKA_MODULUS and
CKA_PUBLIC_EXPONENT are readable - but they should be for all but the dumbest of
PKCS#11 smart cards), which will at least "guarantee" that |key| and
|public_key| are pairwise consistent - which we currently guarantee for the
other create functions.

[Chris Masone, 2013/05/07 21:00:39]

Done.

+  RSAPrivateKey* copy = new RSAPrivateKey();
+  copy->key_ = SECKEY_CopyPrivateKey(key);
+  copy->public_key_ = SECKEY_CopyPublicKey(public_key);
+  return copy;
+}
+
+// static
 RSAPrivateKey* RSAPrivateKey::FindFromPublicKeyInfo(
     const std::vector<uint8>& input) {
   EnsureNSSInit();
 
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey);
 
   // First, decode and save the public key.
   SECItem key_der;
   key_der.type = siBuffer;
   key_der.data = const_cast<unsigned char*>(&input[0]);
@@ skipping 148 matching lines @@
   result->public_key_ = SECKEY_ConvertToPublicKey(result->key_);
   if (!result->public_key_) {
     NOTREACHED();
     return NULL;
   }
 
   return result.release();
 }
 
 }  // namespace crypto