crypto/ec_signature_creator_nss.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "crypto/ec_signature_creator_impl.h"
   6
   7 #include <cryptohi.h>
   8 #include <pk11pub.h>
   9 #include <secerr.h>
  10 #include <sechash.h>
  11 #if defined(OS_POSIX)
  12 #include <unistd.h>
  13 #endif
  14
  15 #include "base/logging.h"
  16 #include "crypto/ec_private_key.h"
  17 #include "crypto/nss_util.h"
  18 #include "crypto/scoped_nss_types.h"
  19
  20 namespace crypto {
  21
  22 namespace {
  23
  24 SECStatus SignData(SECItem* result,
  25                    SECItem* input,
  26                    SECKEYPrivateKey* key,
  27                    HASH_HashType hash_type,
  28                    size_t* out_signature_len) {
  29   if (key->keyType != ecKey) {
  30     DLOG(FATAL) << "Should be using an EC key.";
  31     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  32     return SECFailure;
  33   }
  34
  35   // Hash the input.
  36   std::vector<uint8> hash_data(HASH_ResultLen(hash_type));
  37   SECStatus rv = HASH_HashBuf(
  38       hash_type, &hash_data[0], input->data, input->len);
  39   if (rv != SECSuccess)
  40     return rv;
  41   SECItem hash = {siBuffer, &hash_data[0],
  42                   static_cast<unsigned int>(hash_data.size())};
  43
  44   // Compute signature of hash.
  45   int signature_len = PK11_SignatureLen(key);
  46   std::vector<uint8> signature_data(signature_len);
  47   SECItem sig = {siBuffer, &signature_data[0],
  48                  static_cast<unsigned int>(signature_len)};
  49   rv = PK11_Sign(key, &sig, &hash);
  50   if (rv != SECSuccess)
  51     return rv;
  52
  53   *out_signature_len = sig.len;
  54
  55   // DER encode the signature.
  56   return DSAU_EncodeDerSigWithLen(result, &sig, sig.len);
  57 }
  58
  59 }  // namespace
  60
  61 ECSignatureCreatorImpl::ECSignatureCreatorImpl(ECPrivateKey* key)
  62     : key_(key),
  63       signature_len_(0) {
  64   EnsureNSSInit();
  65 }
  66
  67 ECSignatureCreatorImpl::~ECSignatureCreatorImpl() {}
  68
  69 bool ECSignatureCreatorImpl::Sign(const uint8* data,
  70                                   int data_len,
  71                                   std::vector<uint8>* signature) {
  72   // Data to be signed
  73   SECItem secret;
  74   secret.type = siBuffer;
  75   secret.len = data_len;
  76   secret.data = const_cast<unsigned char*>(data);
  77
  78   // SECItem to receive the output buffer.
  79   SECItem result;
  80   result.type = siBuffer;
  81   result.len = 0;
  82   result.data = NULL;
  83
  84   // Sign the secret data and save it to |result|.
  85   SECStatus rv =
  86       SignData(&result, &secret, key_->key(), HASH_AlgSHA256, &signature_len_);
  87   if (rv != SECSuccess) {
  88     DLOG(ERROR) << "DerSignData: " << PORT_GetError();
  89     return false;
  90   }
  91
  92   // Copy the signed data into the output vector.
  93   signature->assign(result.data, result.data + result.len);
  94   SECITEM_FreeItem(&result, PR_FALSE /* only free |result.data| */);
  95   return true;
  96 }
  97
  98 bool ECSignatureCreatorImpl::DecodeSignature(
  99     const std::vector<uint8>& der_sig,
 100     std::vector<uint8>* out_raw_sig) {
 101   SECItem der_sig_item;
 102   der_sig_item.type = siBuffer;
 103   der_sig_item.len = der_sig.size();
 104   der_sig_item.data = const_cast<uint8*>(&der_sig[0]);
 105
 106   SECItem* raw_sig = DSAU_DecodeDerSigToLen(&der_sig_item, signature_len_);
 107   if (!raw_sig)
 108     return false;
 109   out_raw_sig->assign(raw_sig->data, raw_sig->data + raw_sig->len);
 110   SECITEM_FreeItem(raw_sig, PR_TRUE /* free SECItem structure itself. */);
 111   return true;
 112 }
 113
 114 }  // namespace crypto