Switch //components from vector_as_array to vector::data.

components/webcrypto/algorithms/ecdsa.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 <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/evp.h>
 
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithms/ec.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "crypto/secure_util.h"
@@ skipping 38 matching lines @@
 
 // Formats a DER-encoded signature (ECDSA-Sig-Value as specified in RFC 3279) to
 // the signature format expected by WebCrypto (raw concatenated "r" and "s").
 //
 // TODO(eroman): Where is the specification for WebCrypto's signature format?
 Status ConvertDerSignatureToWebCryptoSignature(
     EVP_PKEY* key,
     std::vector<uint8_t>* signature) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
-  const unsigned char* der_data = vector_as_array(signature);
   crypto::ScopedECDSA_SIG ecdsa_sig(
-      d2i_ECDSA_SIG(NULL, &der_data, static_cast<long>(signature->size())));
+      ECDSA_SIG_from_bytes(signature->data(), signature->size()));
   if (!ecdsa_sig.get())
     return Status::ErrorUnexpected();
 
-  // |der_data| is updated to point to past the end of the DER structure.
-  if (der_data != vector_as_array(signature) + signature->size())
-    return Status::ErrorUnexpected();
-
   // Determine the maximum length of r and s.
   size_t order_size_bytes;
   Status status = GetEcGroupOrderSize(key, &order_size_bytes);
   if (status.IsError())
     return status;
 
   signature->resize(order_size_bytes * 2);
 
-  if (!BN_bn2bin_padded(vector_as_array(signature), order_size_bytes,
+  if (!BN_bn2bin_padded(signature->data(), order_size_bytes,
                         ecdsa_sig.get()->r)) {
     return Status::ErrorUnexpected();
   }
 
   if (!BN_bn2bin_padded(&(*signature)[order_size_bytes], order_size_bytes,
                         ecdsa_sig.get()->s)) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
@@ skipping 44 matching lines @@
     return Status::ErrorUnexpected();
   }
 
   // Determine the size of the DER-encoded signature.
   int der_encoding_size = i2d_ECDSA_SIG(ecdsa_sig.get(), NULL);
   if (der_encoding_size < 0)
     return Status::OperationError();
 
   // DER-encode the signature.
   der_signature->resize(der_encoding_size);
-  uint8_t* result = vector_as_array(der_signature);
+  uint8_t* result = der_signature->data();
   if (0 > i2d_ECDSA_SIG(ecdsa_sig.get(), &result))
     return Status::OperationError();
 
   return Status::Success();
 }
 
 class EcdsaImplementation : public EcAlgorithm {
  public:
   EcdsaImplementation()
       : EcAlgorithm(blink::WebCryptoKeyUsageVerify,
@@ skipping 35 matching lines @@
     // the real one, which may be smaller.
     size_t sig_len = 0;
     if (!ctx.get() ||
         !EVP_DigestSignInit(ctx.get(), NULL, digest, NULL, private_key) ||
         !EVP_DigestSignUpdate(ctx.get(), data.bytes(), data.byte_length()) ||
         !EVP_DigestSignFinal(ctx.get(), NULL, &sig_len)) {
       return Status::OperationError();
     }
 
     buffer->resize(sig_len);
-    if (!EVP_DigestSignFinal(ctx.get(), vector_as_array(buffer), &sig_len))
+    if (!EVP_DigestSignFinal(ctx.get(), buffer->data(), &sig_len))
       return Status::OperationError();
     buffer->resize(sig_len);
 
     // ECDSA signing in BoringSSL outputs a DER-encoded (r,s). WebCrypto however
     // expects a padded bitstring that is r concatenated to s. Convert to the
     // expected format.
     return ConvertDerSignatureToWebCryptoSignature(private_key, buffer);
   }
 
   Status Verify(const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 24 matching lines @@
       *signature_match = false;
       return Status::Success();
     }
 
     if (!EVP_DigestVerifyInit(ctx.get(), NULL, digest, NULL, public_key) ||
         !EVP_DigestVerifyUpdate(ctx.get(), data.bytes(), data.byte_length())) {
       return Status::OperationError();
     }
 
     *signature_match =
-        1 == EVP_DigestVerifyFinal(ctx.get(), vector_as_array(&der_signature),
+        1 == EVP_DigestVerifyFinal(ctx.get(), der_signature.data(),
                                    der_signature.size());
     return Status::Success();
   }
 };
 
 }  // namespace
 
 scoped_ptr<AlgorithmImplementation> CreateEcdsaImplementation() {
   return make_scoped_ptr(new EcdsaImplementation);
 }
 
 }  // namespace webcrypto