crypto/signature_creator_openssl.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/signature_creator.h"
   6
   7 #include <openssl/evp.h>
   8 #include <openssl/rsa.h>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/stl_util.h"
  13 #include "crypto/openssl_util.h"
  14 #include "crypto/rsa_private_key.h"
  15 #include "crypto/scoped_openssl_types.h"
  16
  17 namespace crypto {
  18
  19 namespace {
  20
  21 const EVP_MD* ToOpenSSLDigest(SignatureCreator::HashAlgorithm hash_alg) {
  22   switch (hash_alg) {
  23     case SignatureCreator::SHA1:
  24       return EVP_sha1();
  25     case SignatureCreator::SHA256:
  26       return EVP_sha256();
  27   }
  28   return NULL;
  29 }
  30
  31 int ToOpenSSLDigestType(SignatureCreator::HashAlgorithm hash_alg) {
  32   switch (hash_alg) {
  33     case SignatureCreator::SHA1:
  34       return NID_sha1;
  35     case SignatureCreator::SHA256:
  36       return NID_sha256;
  37   }
  38   return NID_undef;
  39 }
  40
  41 }  // namespace
  42
  43 // static
  44 SignatureCreator* SignatureCreator::Create(RSAPrivateKey* key,
  45                                            HashAlgorithm hash_alg) {
  46   OpenSSLErrStackTracer err_tracer(FROM_HERE);
  47   scoped_ptr<SignatureCreator> result(new SignatureCreator);
  48   result->key_ = key;
  49   const EVP_MD* const digest = ToOpenSSLDigest(hash_alg);
  50   DCHECK(digest);
  51   if (!digest) {
  52     return NULL;
  53   }
  54   if (!EVP_SignInit_ex(result->sign_context_, digest, NULL))
  55     return NULL;
  56   return result.release();
  57 }
  58
  59 // static
  60 bool SignatureCreator::Sign(RSAPrivateKey* key,
  61                             HashAlgorithm hash_alg,
  62                             const uint8* data,
  63                             int data_len,
  64                             std::vector<uint8>* signature) {
  65   ScopedRSA rsa_key(EVP_PKEY_get1_RSA(key->key()));
  66   if (!rsa_key)
  67     return false;
  68   signature->resize(RSA_size(rsa_key.get()));
  69
  70   unsigned int len = 0;
  71   bool success = RSA_sign(ToOpenSSLDigestType(hash_alg), data, data_len,
  72                           vector_as_array(signature), &len, rsa_key.get());
  73   if (!success) {
  74     signature->clear();
  75     return false;
  76   }
  77   signature->resize(len);
  78   return true;
  79 }
  80
  81 SignatureCreator::SignatureCreator()
  82     : sign_context_(EVP_MD_CTX_create()) {
  83 }
  84
  85 SignatureCreator::~SignatureCreator() {
  86   EVP_MD_CTX_destroy(sign_context_);
  87 }
  88
  89 bool SignatureCreator::Update(const uint8* data_part, int data_part_len) {
  90   OpenSSLErrStackTracer err_tracer(FROM_HERE);
  91   return EVP_SignUpdate(sign_context_, data_part, data_part_len) == 1;
  92 }
  93
  94 bool SignatureCreator::Final(std::vector<uint8>* signature) {
  95   OpenSSLErrStackTracer err_tracer(FROM_HERE);
  96   EVP_PKEY* key = key_->key();
  97   signature->resize(EVP_PKEY_size(key));
  98
  99   unsigned int len = 0;
 100   int rv = EVP_SignFinal(sign_context_, vector_as_array(signature), &len, key);
 101   if (!rv) {
 102     signature->clear();
 103     return false;
 104   }
 105   signature->resize(len);
 106   return true;
 107 }
 108
 109 }  // namespace crypto