Remove *_openssl files for gcm_driver

components/gcm_driver/crypto/gcm_message_cryptographer.cc

 // Copyright 2015 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 "components/gcm_driver/crypto/gcm_message_cryptographer.h"
 
+#include <openssl/aead.h>
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <sstream>
 
 #include "base/logging.h"
+#include "base/numerics/safe_math.h"
+#include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "crypto/hkdf.h"
 
 namespace gcm {
 namespace {
 
 // Size, in bytes, of the nonce for a record. This must be at least the size
 // of a uint64_t, which is used to indicate the record sequence number.
 const uint64_t kNonceSize = 12;
 
 // The default record size as defined by draft-thomson-http-encryption.
 const size_t kDefaultRecordSize = 4096;
 
 // Key size, in bytes, of a valid AEAD_AES_128_GCM key.
 const size_t kContentEncryptionKeySize = 16;
 
+// The BoringSSL functions used to seal (encrypt) and open (decrypt) a payload
+// follow the same prototype, declared as follows.
+using EVP_AEAD_CTX_TransformFunction =
+    int(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len,
+        size_t max_out_len, const uint8_t *nonce, size_t nonce_len,
+        const uint8_t *in, size_t in_len, const uint8_t *ad, size_t ad_len);
+
 // Creates the info parameter for an HKDF value for the given |content_encoding|
 // in accordance with draft-thomson-http-encryption.
 //
 // cek_info = "Content-Encoding: aesgcm" || 0x00 || context
 // nonce_info = "Content-Encoding: nonce" || 0x00 || context
 //
 // context = label || 0x00 ||
 //           length(recipient_public) || recipient_public ||
 //           length(sender_public) || sender_public
 //
@@ skipping 146 matching lines @@
   for (size_t i = 0; i < padding_length; ++i) {
     if (decrypted_record[i] != 0)
       return false;
   }
 
   decrypted_record.remove_prefix(padding_length);
   decrypted_record.CopyToString(plaintext);
   return true;
 }
 
+bool GCMMessageCryptographer::EncryptDecryptRecordInternal(
+    Mode mode,
+    const base::StringPiece& input,
+    const base::StringPiece& key,
+    const base::StringPiece& nonce,
+    std::string* output) const {
+  DCHECK(output);
+
+  const EVP_AEAD* aead = EVP_aead_aes_128_gcm();
+
+  EVP_AEAD_CTX context;
+  if (!EVP_AEAD_CTX_init(&context, aead,
+                         reinterpret_cast<const uint8_t*>(key.data()),
+                         key.size(), EVP_AEAD_DEFAULT_TAG_LENGTH, nullptr)) {
+    return false;
+  }
+
+  base::CheckedNumeric<size_t> maximum_output_length(input.size());
+  if (mode == ENCRYPT)
+    maximum_output_length += kAuthenticationTagBytes;
+
+  // WriteInto requires the buffer to finish with a NULL-byte.
+  maximum_output_length += 1;
+
+  size_t output_length = 0;
+  uint8_t* raw_output = reinterpret_cast<uint8_t*>(
+      base::WriteInto(output, maximum_output_length.ValueOrDie()));
+
+  EVP_AEAD_CTX_TransformFunction* transform_function =
+      mode == ENCRYPT ? EVP_AEAD_CTX_seal : EVP_AEAD_CTX_open;
+
+  if (!transform_function(
+          &context, raw_output, &output_length, output->size(),
+          reinterpret_cast<const uint8_t*>(nonce.data()), nonce.size(),
+          reinterpret_cast<const uint8_t*>(input.data()), input.size(),
+          nullptr, 0)) {
+    EVP_AEAD_CTX_cleanup(&context);
+    return false;
+  }
+
+  EVP_AEAD_CTX_cleanup(&context);
+
+  base::CheckedNumeric<size_t> expected_output_length(input.size());
+  if (mode == ENCRYPT)
+    expected_output_length += kAuthenticationTagBytes;
+  else
+    expected_output_length -= kAuthenticationTagBytes;
+
+  DCHECK_EQ(expected_output_length.ValueOrDie(), output_length);
+
+  output->resize(output_length);
+  return true;
+}
+
 std::string GCMMessageCryptographer::DerivePseudoRandomKey(
     const base::StringPiece& ikm) const {
   if (allow_empty_auth_secret_for_tests_ && auth_secret_.empty())
     return ikm.as_string();
 
   CHECK(!auth_secret_.empty());
 
   std::stringstream info_stream;
   info_stream << "Content-Encoding: auth" << '\x00';
 
@@ skipping 28 matching lines @@
                     0   /* subkey_secret_bytes_to_generate */);
 
   // draft-thomson-http-encryption defines that the result should be XOR'ed with
   // the record's sequence number, however, Web Push encryption is limited to a
   // single record per draft-ietf-webpush-encryption.
 
   return hkdf.client_write_key().as_string();
 }
 
 }  // namespace gcm