Introduce RSAPrivateKey::SignDigest

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 177 matching lines @@
   ScopedSECItem der_pubkey(SECKEY_EncodeDERSubjectPublicKeyInfo(public_key_));
   if (!der_pubkey.get()) {
     NOTREACHED();
     return false;
   }
 
   output->assign(der_pubkey->data, der_pubkey->data + der_pubkey->len);
   return true;
 }
 
+bool RSAPrivateKey::SignDigest(const std::vector<uint8>& digest,
+                               std::vector<uint8>* output) const {
+  size_t signature_len = PK11_SignatureLen(key_);
+
+  SECItem digest_item;
+  digest_item.type = siBuffer;
+  digest_item.data = const_cast<unsigned char*>(&digest[0]);
+  digest_item.len = digest.size();
+
+  SECItem signature_item;
+  signature_item.len = signature_len;
+  signature_item.data = (unsigned char*) PORT_Alloc(signature_len);
+  SECStatus rv = PK11_Sign(key_, &signature_item, &digest_item);
+  if (rv != SECSuccess) {
+    NOTREACHED();
+    SECITEM_FreeItem(&signature_item, PR_FALSE);
+    return false;
+  }
+
+  output->assign(signature_item.data,
+                 signature_item.data + signature_item.len);
+  SECITEM_FreeItem(&signature_item, PR_FALSE);
+  return true;
+}
+
 RSAPrivateKey::RSAPrivateKey() : key_(NULL), public_key_(NULL) {
   EnsureNSSInit();
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateWithParams(uint16 num_bits,
                                                bool permanent,
                                                bool sensitive) {
 #if !defined(USE_NSS)
   if (permanent) {
@@ skipping 67 matching lines @@
   result->public_key_ = SECKEY_ConvertToPublicKey(result->key_);
   if (!result->public_key_) {
     NOTREACHED();
     return NULL;
   }
 
   return result.release();
 }
 
 }  // namespace crypto