DONOTLAND: Start of PK11 password dialog for Linux/NSS

net/third_party/mozilla_security_manager/nsKeygenHandler.cpp

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
@@ skipping 31 matching lines @@
 
 #include <pk11pub.h>
 #include <prerror.h>   // PR_GetError()
 #include <secmod.h>
 #include <secder.h>    // DER_Encode()
 #include <cryptohi.h>  // SEC_DerSignData()
 #include <keyhi.h>     // SECKEY_CreateSubjectPublicKeyInfo()
 
 #include "base/base64.h"
 #include "base/logging.h"
-#include "base/nss_util_internal.h"
 #include "base/nss_util.h"
-#include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
 // Template for creating the signed public key structure to be sent to the CA.
 DERTemplate SECAlgorithmIDTemplate[] = {
   { DER_SEQUENCE,
     0, NULL, sizeof(SECAlgorithmID) },
   { DER_OBJECT_ID,
     offsetof(SECAlgorithmID, algorithm), },
@@ skipping 25 matching lines @@
 
 }  // namespace
 
 namespace mozilla_security_manager {
 
 // This function is based on the nsKeygenFormProcessor::GetPublicKey function
 // in mozilla/security/manager/ssl/src/nsKeygenHandler.cpp.
 std::string GenKeyAndSignChallenge(int key_size_in_bits,
                                    const std::string& challenge,
                                    const GURL& url,
+                                   PK11SlotInfo* slot,
                                    bool stores_key) {
   // Key pair generation mechanism - only RSA is supported at present.
   PRUint32 keyGenMechanism = CKM_RSA_PKCS_KEY_PAIR_GEN;  // from nss/pkcs11t.h
 
   // Temporary structures used for generating the result
   // in the right format.
-  PK11SlotInfo *slot = NULL;
   PK11RSAGenParams rsaKeyGenParams;  // Keygen parameters.
   SECOidTag algTag;  // used by SEC_DerSignData().
   SECKEYPrivateKey *privateKey = NULL;
   SECKEYPublicKey *publicKey = NULL;
   CERTSubjectPublicKeyInfo *spkInfo = NULL;
   PRArenaPool *arena = NULL;
   SECStatus sec_rv =SECFailure;
   SECItem spkiItem;
   SECItem pkacItem;
   SECItem signedItem;
   CERTPublicKeyAndChallenge pkac;
   void *keyGenParams;
   bool isSuccess = true;  // Set to false as soon as a step fails.
 
   std::string result_blob;  // the result.
 
-  // Ensure NSS is initialized.
-  base::EnsureNSSInit();
-
-  slot = base::GetDefaultNSSKeySlot();
-  if (!slot) {
-    LOG(ERROR) << "Couldn't get Internal key slot!";
-    isSuccess = false;
-    goto failure;
-  }
-
   switch (keyGenMechanism) {
     case CKM_RSA_PKCS_KEY_PAIR_GEN:
       rsaKeyGenParams.keySizeInBits = key_size_in_bits;
       rsaKeyGenParams.pe = DEFAULT_RSA_KEYGEN_PE;
       keyGenParams = &rsaKeyGenParams;
 
       algTag = DEFAULT_RSA_KEYGEN_ALG;
       break;
     default:
       // TODO(gauravsh): If we ever support other mechanisms,
       // this can be changed.
       LOG(ERROR) << "Only RSA keygen mechanism is supported";
       isSuccess = false;
       goto failure;
   }
 
-  // Need to make sure that the token was initialized.
-  // Assume a null password.
-  sec_rv = PK11_Authenticate(slot, PR_TRUE, NULL);
-  if (SECSuccess != sec_rv) {
-    LOG(ERROR) << "Couldn't initialze PK11 token!";
-    isSuccess = false;
-    goto failure;
-  }
-
   LOG(INFO) << "Creating key pair...";
   {
     base::AutoNSSWriteLock lock;
     privateKey = PK11_GenerateKeyPair(slot,
                                       keyGenMechanism,
                                       keyGenParams,
                                       &publicKey,
                                       PR_TRUE,  // isPermanent?
                                       PR_TRUE,  // isSensitive?
                                       NULL);
@@ skipping 100 matching lines @@
       PK11_DestroyTokenObject(publicKey->pkcs11Slot, publicKey->pkcs11ID);
     }
     SECKEY_DestroyPublicKey(publicKey);
   }
   if (spkInfo) {
     SECKEY_DestroySubjectPublicKeyInfo(spkInfo);
   }
   if (arena) {
     PORT_FreeArena(arena, PR_TRUE);
   }
-  if (slot != NULL) {
-    PK11_FreeSlot(slot);
-  }
 
   return (isSuccess ? result_blob : std::string());
 }
 
 }  // namespace mozilla_security_manager