[webcrypto] Set the error type for failures.

content/child/webcrypto/platform_crypto_openssl.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 "content/child/webcrypto/platform_crypto.h"
 
 #include <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
@@ skipping 81 matching lines @@
     // now it doesn't make much difference since the one-shot API would end up
     // blowing out the memory and crashing anyway.
     return Status::ErrorDataTooLarge();
   }
 
   // Note: PKCS padding is enabled by default
   crypto::ScopedOpenSSL<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> context(
       EVP_CIPHER_CTX_new());
 
   if (!context.get())
-    return Status::Error();
+    return Status::OperationError();
 
   const EVP_CIPHER* const cipher = GetAESCipherByKeyLength(key->key().size());
   DCHECK(cipher);
 
   if (!EVP_CipherInit_ex(context.get(),
                          cipher,
                          NULL,
                          &key->key()[0],
                          iv.bytes(),
                          cipher_operation)) {
-    return Status::Error();
+    return Status::OperationError();
   }
 
   // According to the openssl docs, the amount of data written may be as large
   // as (data_size + cipher_block_size - 1), constrained to a multiple of
   // cipher_block_size.
   unsigned int output_max_len = data.byte_length() + AES_BLOCK_SIZE - 1;
   const unsigned remainder = output_max_len % AES_BLOCK_SIZE;
   if (remainder != 0)
     output_max_len += AES_BLOCK_SIZE - remainder;
   DCHECK_GT(output_max_len, data.byte_length());
 
   *buffer = blink::WebArrayBuffer::create(output_max_len, 1);
 
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
   int output_len = 0;
   if (!EVP_CipherUpdate(context.get(),
                         buffer_data,
                         &output_len,
                         data.bytes(),
                         data.byte_length()))
-    return Status::Error();
+    return Status::OperationError();
   int final_output_chunk_len = 0;
   if (!EVP_CipherFinal_ex(
           context.get(), buffer_data + output_len, &final_output_chunk_len)) {
-    return Status::Error();
+    return Status::OperationError();
   }
 
   const unsigned int final_output_len =
       static_cast<unsigned int>(output_len) +
       static_cast<unsigned int>(final_output_chunk_len);
   DCHECK_LE(final_output_len, output_max_len);
 
   ShrinkBuffer(buffer, final_output_len);
 
   return Status::Success();
@@ skipping 12 matching lines @@
     return ConsumeWithStatus(data, size).IsSuccess();
   }
 
   Status ConsumeWithStatus(const unsigned char* data, unsigned int size) {
     crypto::OpenSSLErrStackTracer(FROM_HERE);
     Status error = Init();
     if (!error.IsSuccess())
       return error;
 
     if (!EVP_DigestUpdate(digest_context_.get(), data, size))
-      return Status::Error();
+      return Status::OperationError();
 
     return Status::Success();
   }
 
   virtual bool finish(unsigned char*& result_data,
                       unsigned int& result_data_size) {
     Status error = FinishInternal(result_, &result_data_size);
     if (!error.IsSuccess())
       return false;
     result_data = result_;
@@ skipping 15 matching lines @@
  private:
   Status Init() {
     if (initialized_)
       return Status::Success();
 
     const EVP_MD* digest_algorithm = GetDigest(algorithm_id_);
     if (!digest_algorithm)
       return Status::ErrorUnexpected();
 
     if (!digest_context_.get())
-      return Status::Error();
+      return Status::OperationError();
 
     if (!EVP_DigestInit_ex(digest_context_.get(), digest_algorithm, NULL))
-      return Status::Error();
+      return Status::OperationError();
 
     initialized_ = true;
     return Status::Success();
   }
 
   Status FinishInternal(unsigned char* result, unsigned int* result_size) {
     crypto::OpenSSLErrStackTracer(FROM_HERE);
     Status error = Init();
     if (!error.IsSuccess())
       return error;
 
     const int hash_expected_size = EVP_MD_CTX_size(digest_context_.get());
     if (hash_expected_size <= 0)
       return Status::ErrorUnexpected();
     DCHECK_LE(hash_expected_size, EVP_MAX_MD_SIZE);
 
     if (!EVP_DigestFinal_ex(digest_context_.get(), result, result_size) ||
         static_cast<int>(*result_size) != hash_expected_size)
-      return Status::Error();
+      return Status::OperationError();
 
     return Status::Success();
   }
 
   bool initialized_;
   crypto::ScopedOpenSSL<EVP_MD_CTX, EVP_MD_CTX_destroy> digest_context_;
   blink::WebCryptoAlgorithmId algorithm_id_;
   unsigned char result_[EVP_MAX_MD_SIZE];
 };
 
@@ skipping 35 matching lines @@
                          unsigned keylen_bytes,
                          blink::WebCryptoKey* key) {
   // TODO(eroman): Is this right?
   if (keylen_bytes == 0)
     return Status::ErrorGenerateKeyLength();
 
   crypto::OpenSSLErrStackTracer(FROM_HERE);
 
   std::vector<unsigned char> random_bytes(keylen_bytes, 0);
   if (!(RAND_bytes(&random_bytes[0], keylen_bytes)))
-    return Status::Error();
+    return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreateSecretKeyAlgorithm(algorithm, keylen_bytes, &key_algorithm))
     return Status::ErrorUnexpected();
 
   *key = blink::WebCryptoKey::create(new SymKey(CryptoData(random_bytes)),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
@@ skipping 63 matching lines @@
 
   unsigned int hmac_actual_length;
   unsigned char* const success = HMAC(digest_algorithm,
                                       raw_key_voidp,
                                       raw_key.size(),
                                       data.bytes(),
                                       data.byte_length(),
                                       hmac_result.safe_buffer(),
                                       &hmac_actual_length);
   if (!success || hmac_actual_length != hmac_expected_length)
-    return Status::Error();
+    return Status::OperationError();
 
   *buffer = result;
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usage_mask,
                           const CryptoData& modulus_data,
                           const CryptoData& exponent_data,
@@ skipping 123 matching lines @@
                          blink::WebCryptoKey* key) {
   // TODO(eroman): http://crbug.com/267888
   return Status::ErrorUnsupported();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content