enterprise.platformKeys: Support the publicExponent parameter.

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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 "chrome/browser/chromeos/platform_keys/platform_keys.h"
 
 #include <cryptohi.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 108 matching lines @@
                           FROM_HERE,
                           base::Bind(&GetCertDatabaseOnIOThread,
                                      profile->GetResourceContext(),
                                      callback,
                                      state));
 }
 
 class GenerateRSAKeyState : public NSSOperationState {
  public:
   GenerateRSAKeyState(unsigned int modulus_length,
+                      unsigned long public_exponent,
                       const GenerateKeyCallback& callback);
   virtual ~GenerateRSAKeyState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
                        const std::string& error_message) OVERRIDE {
     CallBack(from, std::string() /* no public key */, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& public_key_spki_der,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, public_key_spki_der, error_message));
   }
 
-  unsigned int modulus_length_;
+  const unsigned int modulus_length_;
+  const long public_exponent_;
 
  private:
   // Must be called on origin thread, use CallBack() therefore.
   GenerateKeyCallback callback_;
 };
 
 class SignState : public NSSOperationState {
  public:
   SignState(const std::string& public_key,
             const std::string& data,
             const SignCallback& callback);
   virtual ~SignState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
                        const std::string& error_message) OVERRIDE {
     CallBack(from, std::string() /* no signature */, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& signature,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, signature, error_message));
   }
 
-  std::string public_key_;
-  std::string data_;
+  const std::string public_key_;
+  const std::string data_;
 
  private:
   // Must be called on origin thread, use CallBack() therefore.
   SignCallback callback_;
 };
 
 class GetCertificatesState : public NSSOperationState {
  public:
   explicit GetCertificatesState(const GetCertificatesCallback& callback);
   virtual ~GetCertificatesState() {}
@@ skipping 63 matching lines @@
  private:
   // Must be called on origin thread, use CallBack() therefore.
   RemoveCertificateCallback callback_;
 };
 
 NSSOperationState::NSSOperationState()
     : origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
 }
 
 GenerateRSAKeyState::GenerateRSAKeyState(unsigned int modulus_length,
+                                         unsigned long public_exponent,
                                          const GenerateKeyCallback& callback)
-    : modulus_length_(modulus_length), callback_(callback) {
+    : modulus_length_(modulus_length),
+      public_exponent_(public_exponent),
+      callback_(callback) {
 }
 
 SignState::SignState(const std::string& public_key,
                      const std::string& data,
                      const SignCallback& callback)
     : public_key_(public_key), data_(data), callback_(callback) {
 }
 
 GetCertificatesState::GetCertificatesState(
     const GetCertificatesCallback& callback)
     : callback_(callback) {
 }
 
 ImportCertificateState::ImportCertificateState(
     scoped_refptr<net::X509Certificate> certificate,
     const ImportCertificateCallback& callback)
     : certificate_(certificate), callback_(callback) {
 }
 
 RemoveCertificateState::RemoveCertificateState(
     scoped_refptr<net::X509Certificate> certificate,
     const RemoveCertificateCallback& callback)
     : certificate_(certificate), callback_(callback) {
 }
 
 // Does the actual key generation on a worker thread. Used by
 // GenerateRSAKeyWithDB().
 void GenerateRSAKeyOnWorkerThread(scoped_ptr<GenerateRSAKeyState> state) {
   scoped_ptr<crypto::RSAPrivateKey> rsa_key(
-      crypto::RSAPrivateKey::CreateSensitive(state->slot_.get(),
-                                             state->modulus_length_));
+      crypto::RSAPrivateKey::CreateSensitive(
+          state->slot_.get(), state->modulus_length_, state->public_exponent_));
   if (!rsa_key) {
     LOG(ERROR) << "Couldn't create key.";
     state->OnError(FROM_HERE, kErrorInternal);
     return;
   }
 
   std::vector<uint8> public_key_spki_der;
   if (!rsa_key->ExportPublicKey(&public_key_spki_der)) {
     // TODO(pneubeck): Remove rsa_key from storage.
     LOG(ERROR) << "Couldn't export public key.";
@@ skipping 165 matching lines @@
   cert_db->DeleteCertAndKeyAsync(
       certificate,
       base::Bind(
           &DidRemoveCertificate, base::Passed(&state), certificate_found));
 }
 
 }  // namespace
 
 void GenerateRSAKey(const std::string& token_id,
                     unsigned int modulus_length,
+                    unsigned long public_exponent,
                     const GenerateKeyCallback& callback,
                     Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<GenerateRSAKeyState> state(
-      new GenerateRSAKeyState(modulus_length, callback));
+      new GenerateRSAKeyState(modulus_length, public_exponent, callback));
 
   if (modulus_length > kMaxRSAModulusLength) {
     state->OnError(FROM_HERE, kErrorAlgorithmNotSupported);
     return;
   }
 
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(token_id,
                   base::Bind(&GenerateRSAKeyWithDB, base::Passed(&state)),
@@ skipping 66 matching lines @@
   // we would get more informative error messages.
   GetCertDatabase(token_id,
                   base::Bind(&RemoveCertificateWithDB, base::Passed(&state)),
                   profile,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos