Revert "Switch to BoringSSL."

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 35 matching lines @@
 
  private:
   const std::vector<unsigned char> key_;
 
   DISALLOW_COPY_AND_ASSIGN(SymKey);
 };
 
 namespace {
 
 const EVP_CIPHER* GetAESCipherByKeyLength(unsigned int key_length_bytes) {
-  // OpenSSL supports AES CBC ciphers for only 2 key lengths: 128, 256 bits
+  // OpenSSL supports AES CBC ciphers for only 3 key lengths: 128, 192, 256 bits
   switch (key_length_bytes) {
     case 16:
       return EVP_aes_128_cbc();
+    case 24:
+      return EVP_aes_192_cbc();
     case 32:
       return EVP_aes_256_cbc();
     default:
       return NULL;
   }
 }
 
 const EVP_MD* GetDigest(blink::WebCryptoAlgorithmId id) {
   switch (id) {
     case blink::WebCryptoAlgorithmIdSha1:
@@ skipping 360 matching lines @@
                          Uint8VectorStart(key->key()),
                          key->key().size(),
                          tag_length_bytes,
                          NULL)) {
     return Status::OperationError();
   }
 
   crypto::ScopedOpenSSL<EVP_AEAD_CTX, EVP_AEAD_CTX_cleanup>::Type ctx_cleanup(
       &ctx);
 
-  size_t len;
-  int ok;
+  ssize_t len;
 
   if (mode == DECRYPT) {
     if (data.byte_length() < tag_length_bytes)
       return Status::ErrorDataTooSmall();
 
     buffer->resize(data.byte_length() - tag_length_bytes);
 
-    ok = EVP_AEAD_CTX_open(&ctx,
-                           Uint8VectorStart(buffer),
-                           &len,
-                           buffer->size(),
-                           iv.bytes(),
-                           iv.byte_length(),
-                           data.bytes(),
-                           data.byte_length(),
-                           additional_data.bytes(),
-                           additional_data.byte_length());
+    len = EVP_AEAD_CTX_open(&ctx,
+                            Uint8VectorStart(buffer),
+                            buffer->size(),
+                            iv.bytes(),
+                            iv.byte_length(),
+                            data.bytes(),
+                            data.byte_length(),
+                            additional_data.bytes(),
+                            additional_data.byte_length());
   } else {
     // No need to check for unsigned integer overflow here (seal fails if
     // the output buffer is too small).
     buffer->resize(data.byte_length() + tag_length_bytes);
 
-    ok = EVP_AEAD_CTX_seal(&ctx,
-                           Uint8VectorStart(buffer),
-                           &len,
-                           buffer->size(),
-                           iv.bytes(),
-                           iv.byte_length(),
-                           data.bytes(),
-                           data.byte_length(),
-                           additional_data.bytes(),
-                           additional_data.byte_length());
+    len = EVP_AEAD_CTX_seal(&ctx,
+                            Uint8VectorStart(buffer),
+                            buffer->size(),
+                            iv.bytes(),
+                            iv.byte_length(),
+                            data.bytes(),
+                            data.byte_length(),
+                            additional_data.bytes(),
+                            additional_data.byte_length());
   }
 
-  if (!ok)
+  if (len < 0)
     return Status::OperationError();
   buffer->resize(len);
   return Status::Success();
 }
 
 Status EncryptRsaOaep(PublicKey* key,
                       const blink::WebCryptoAlgorithm& hash,
                       const CryptoData& label,
                       const CryptoData& data,
                       std::vector<uint8>* buffer) {
@@ skipping 95 matching lines @@
     blink::WebCryptoKey* key) {
   // TODO(eroman): http://crbug.com/267888
   return false;
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content