enterprise.platformKeys: Support the publicExponent parameter.

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 69 matching lines @@
     SECKEY_DestroyPublicKey(public_key_);
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) {
   EnsureNSSInit();
 
   ScopedPK11Slot slot(PK11_GetInternalSlot());
   return CreateWithParams(slot.get(),
                           num_bits,
+                          kDefaultPublicExponent,
                           false /* not permanent */,
                           false /* not sensitive */);
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateFromPrivateKeyInfo(
     const std::vector<uint8>& input) {
   EnsureNSSInit();
 
   ScopedPK11Slot slot(PK11_GetInternalSlot());
   return CreateFromPrivateKeyInfoWithParams(
       slot.get(),
       input,
       false /* not permanent */,
       false /* not sensitive */);
 }
 
 #if defined(USE_NSS)
+uint64 RSAPrivateKey::kDefaultPublicExponent = 65537L;

[Ryan Sleevi, 2014/06/03 19:35:29]

1) Wrong suffix
2) Wrong format for declaring constants

uint64 RSAPrivateKey::kDefaultPublicExponent = UINT64_C(65537);

+
 // static
 RSAPrivateKey* RSAPrivateKey::CreateSensitive(PK11SlotInfo* slot,
-                                              uint16 num_bits) {
+                                              uint16 num_bits,
+                                              uint64 public_exponent) {
   return CreateWithParams(slot,
                           num_bits,
+                          public_exponent,
                           true /* permanent */,
                           true /* sensitive */);
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateSensitiveFromPrivateKeyInfo(
     PK11SlotInfo* slot,
     const std::vector<uint8>& input) {
   return CreateFromPrivateKeyInfoWithParams(slot,
                                             input,
@@ skipping 114 matching lines @@
   return true;
 }
 
 RSAPrivateKey::RSAPrivateKey() : key_(NULL), public_key_(NULL) {
   EnsureNSSInit();
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateWithParams(PK11SlotInfo* slot,
                                                uint16 num_bits,
+                                               uint64 public_exponent,
                                                bool permanent,
                                                bool sensitive) {
   if (!slot)
     return NULL;
 
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey);
 
   PK11RSAGenParams param;
   param.keySizeInBits = num_bits;
-  param.pe = 65537L;
+  param.pe = public_exponent;
   result->key_ = PK11_GenerateKeyPair(slot,
                                       CKM_RSA_PKCS_KEY_PAIR_GEN,
                                       &param,
                                       &result->public_key_,
                                       permanent,
                                       sensitive,
                                       NULL);
   if (!result->key_)
     return NULL;
 
@@ skipping 45 matching lines @@
   if (!result->public_key_) {
     NOTREACHED();
     return NULL;
   }
 
   return result.release();
 }
 #endif  // defined(USE_NSS)
 
 }  // namespace crypto