Copy array buffer data used by WebCrypto in the order expected by draft specification.

third_party/WebKit/Source/modules/crypto/NormalizeAlgorithm.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 #include "core/dom/DOMTypedArray.h"
 #include "public/platform/WebCryptoAlgorithmParams.h"
 #include "public/platform/WebString.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 #include <memory>
 
+// TODO(eroman): Change the interface for constructing
+//               WebCryptoAlgorithmParams to allow transferring byte
+//               parameters (whereas currently it makes a copy).
+
 namespace blink {
 
 namespace {
 
 typedef ArrayBufferOrArrayBufferView BufferSource;
 
 struct AlgorithmNameMapping {
     // Must be an upper case ASCII string.
     const char* const algorithmName;
     // Must be strlen(algorithmName).
@@ skipping 204 matching lines @@
         stack.add(message2);
         return stack.toString();
     }
 
 private:
     // This inline size is large enough to avoid having to grow the Vector in
     // the majority of cases (up to 1 nested algorithm identifier).
     Vector<const char*, 10> m_messages;
 };
 
+static Vector<uint8_t> copyBytes(const DOMArrayPiece& source)
+{
+    Vector<uint8_t> result;
+    result.append(reinterpret_cast<const uint8_t*>(source.data()), source.byteLength());
+    return result;
+}
+
 // Defined by the WebCrypto spec as:
 //
 //     typedef (ArrayBuffer or ArrayBufferView) BufferSource;
 //
-bool getOptionalBufferSource(const Dictionary& raw, const char* propertyName, bool& hasProperty, BufferSource& buffer, const ErrorContext& context, AlgorithmError* error)
+bool getOptionalBufferSource(const Dictionary& raw, const char* propertyName, bool& hasProperty, Vector<uint8_t>& bytes, const ErrorContext& context, AlgorithmError* error)
 {
     hasProperty = false;
     v8::Local<v8::Value> v8Value;
     if (!raw.get(propertyName, v8Value))
         return true;
     hasProperty = true;
 
     if (v8Value->IsArrayBufferView()) {
-        buffer.setArrayBufferView(V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value)));
+        bytes = copyBytes(V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value)));
         return true;
     }
 
     if (v8Value->IsArrayBuffer()) {
-        buffer.setArrayBuffer(V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value)));
+        bytes = copyBytes(V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value)));
         return true;
     }
 
     if (hasProperty) {
         setTypeError(context.toString(propertyName, "Not a BufferSource"), error);
         return false;
     }
     return true;
 }
 
-bool getBufferSource(const Dictionary& raw, const char* propertyName, BufferSource& buffer, const ErrorContext& context, AlgorithmError* error)
+bool getBufferSource(const Dictionary& raw, const char* propertyName, Vector<uint8_t>& bytes, const ErrorContext& context, AlgorithmError* error)
 {
     bool hasProperty;
-    bool ok = getOptionalBufferSource(raw, propertyName, hasProperty, buffer, context, error);
+    bool ok = getOptionalBufferSource(raw, propertyName, hasProperty, bytes, context, error);
     if (!hasProperty) {
         setTypeError(context.toString(propertyName, "Missing required property"), error);
         return false;
     }
     return ok;
 }
 
-bool getUint8Array(const Dictionary& raw, const char* propertyName, DOMUint8Array*& array, const ErrorContext& context, AlgorithmError* error)
+bool getUint8Array(const Dictionary& raw, const char* propertyName, Vector<uint8_t>& bytes, const ErrorContext& context, AlgorithmError* error)
 {
+    DOMUint8Array* array = nullptr;
     if (!DictionaryHelper::get(raw, propertyName, array) || !array) {
         setTypeError(context.toString(propertyName, "Missing or not a Uint8Array"), error);
         return false;
     }
+    bytes = copyBytes(array);
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     typedef Uint8Array BigInteger;
-bool getBigInteger(const Dictionary& raw, const char* propertyName, DOMUint8Array*& array, const ErrorContext& context, AlgorithmError* error)
+bool getBigInteger(const Dictionary& raw, const char* propertyName, Vector<uint8_t>& bytes, const ErrorContext& context, AlgorithmError* error)
 {
-    if (!getUint8Array(raw, propertyName, array, context, error))
+    if (!getUint8Array(raw, propertyName, bytes, context, error))
         return false;
 
-    if (!array->byteLength()) {
+    if (bytes.isEmpty()) {
         // Empty BigIntegers represent 0 according to the spec
-        array = DOMUint8Array::create(1);
+        bytes.fill(0, 1);
     }
 
     return true;
 }
 
 // Gets an integer according to WebIDL's [EnforceRange].
 bool getOptionalInteger(const Dictionary& raw, const char* propertyName, bool& hasProperty, double& value, double minValue, double maxValue, const ErrorContext& context, AlgorithmError* error)
 {
     double number;
     bool ok = DictionaryHelper::get(raw, propertyName, number, hasProperty);
@@ skipping 101 matching lines @@
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCbcParams : Algorithm {
 //      required BufferSource iv;
 //    };
 bool parseAesCbcParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    BufferSource ivBufferSource;
-    if (!getBufferSource(raw, "iv", ivBufferSource, context, error))
+    Vector<uint8_t> iv;
+    if (!getBufferSource(raw, "iv", iv, context, error))
         return false;
 
-    DOMArrayPiece iv(ivBufferSource);
-
-    params = wrapUnique(new WebCryptoAesCbcParams(iv.bytes(), iv.byteLength()));
+    params = wrapUnique(new WebCryptoAesCbcParams(iv.data(), iv.size()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesKeyGenParams : Algorithm {
 //      [EnforceRange] required unsigned short length;
 //    };
 bool parseAesKeyGenParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
@@ skipping 87 matching lines @@
 //
 //    dictionary RsaHashedKeyGenParams : RsaKeyGenParams {
 //      required HashAlgorithmIdentifier hash;
 //    };
 bool parseRsaHashedKeyGenParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     uint32_t modulusLength;
     if (!getUint32(raw, "modulusLength", modulusLength, context, error))
         return false;
 
-    DOMUint8Array* publicExponent = nullptr;
+    Vector<uint8_t> publicExponent;
     if (!getBigInteger(raw, "publicExponent", publicExponent, context, error))
         return false;
 
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
+    params = wrapUnique(new WebCryptoRsaHashedKeyGenParams(hash, modulusLength, publicExponent.data(), publicExponent.size()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCtrParams : Algorithm {
 //      required BufferSource counter;
 //      [EnforceRange] required octet length;
 //    };
 bool parseAesCtrParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    BufferSource counterBufferSource;
-    if (!getBufferSource(raw, "counter", counterBufferSource, context, error))
+    Vector<uint8_t> counter;
+    if (!getBufferSource(raw, "counter", counter, context, error))
         return false;
 
-    DOMArrayPiece counter(counterBufferSource);
     uint8_t length;
     if (!getUint8(raw, "length", length, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoAesCtrParams(length, counter.bytes(), counter.byteLength()));
+    params = wrapUnique(new WebCryptoAesCtrParams(length, counter.data(), counter.size()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary AesGcmParams : Algorithm {
 //       required BufferSource iv;
 //       BufferSource additionalData;
 //       [EnforceRange] octet tagLength;
 //     }
 bool parseAesGcmParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    BufferSource ivBufferSource;
-    if (!getBufferSource(raw, "iv", ivBufferSource, context, error))
+    Vector<uint8_t> iv;
+    if (!getBufferSource(raw, "iv", iv, context, error))
         return false;
 
     bool hasAdditionalData;
-    BufferSource additionalDataBufferSource;
-    if (!getOptionalBufferSource(raw, "additionalData", hasAdditionalData, additionalDataBufferSource, context, error))
+    Vector<uint8_t> additionalData;
+    if (!getOptionalBufferSource(raw, "additionalData", hasAdditionalData, additionalData, context, error))
         return false;
 
     uint8_t tagLength = 0;
     bool hasTagLength;
     if (!getOptionalUint8(raw, "tagLength", hasTagLength, tagLength, context, error))
         return false;
 
-    DOMArrayPiece iv(ivBufferSource);
-    DOMArrayPiece additionalData(additionalDataBufferSource, DOMArrayPiece::AllowNullPointToNullWithZeroSize);
-
-    params = wrapUnique(new WebCryptoAesGcmParams(iv.bytes(), iv.byteLength(), hasAdditionalData, additionalData.bytes(), additionalData.byteLength(), hasTagLength, tagLength));
+    params = wrapUnique(new WebCryptoAesGcmParams(iv.data(), iv.size(), hasAdditionalData, additionalData.data(), additionalData.size(), hasTagLength, tagLength));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary RsaOaepParams : Algorithm {
 //       BufferSource label;
 //     };
 bool parseRsaOaepParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     bool hasLabel;
-    BufferSource labelBufferSource;
-    if (!getOptionalBufferSource(raw, "label", hasLabel, labelBufferSource, context, error))
+    Vector<uint8_t> label;
+    if (!getOptionalBufferSource(raw, "label", hasLabel, label, context, error))
         return false;
 
-    DOMArrayPiece label(labelBufferSource, DOMArrayPiece::AllowNullPointToNullWithZeroSize);
-    params = wrapUnique(new WebCryptoRsaOaepParams(hasLabel, label.bytes(), label.byteLength()));
+    params = wrapUnique(new WebCryptoRsaOaepParams(hasLabel, label.data(), label.size()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary RsaPssParams : Algorithm {
 //       [EnforceRange] required unsigned long saltLength;
 //     };
 bool parseRsaPssParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
@@ skipping 108 matching lines @@
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary Pbkdf2Params : Algorithm {
 //       required BufferSource salt;
 //       [EnforceRange] required unsigned long iterations;
 //       required HashAlgorithmIdentifier hash;
 //     };
 bool parsePbkdf2Params(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    BufferSource saltBufferSource;
-    if (!getBufferSource(raw, "salt", saltBufferSource, context, error))
+    Vector<uint8_t> salt;
+    if (!getBufferSource(raw, "salt", salt, context, error))
         return false;
 
-    DOMArrayPiece salt(saltBufferSource);
-
     uint32_t iterations;
     if (!getUint32(raw, "iterations", iterations, context, error))
         return false;
 
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
-    params = wrapUnique(new WebCryptoPbkdf2Params(hash, salt.bytes(), salt.byteLength(), iterations));
+    params = wrapUnique(new WebCryptoPbkdf2Params(hash, salt.data(), salt.size(), iterations));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesDerivedKeyParams : Algorithm {
 //      [EnforceRange] required unsigned short length;
 //    };
 bool parseAesDerivedKeyParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
@@ skipping 15 matching lines @@
 //    dictionary HkdfParams : Algorithm {
 //      required HashAlgorithmIdentifier hash;
 //      required BufferSource salt;
 //      required BufferSource info;
 //    };
 bool parseHkdfParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
-    BufferSource saltBufferSource;
-    if (!getBufferSource(raw, "salt", saltBufferSource, context, error))
+    Vector<uint8_t> salt;
+    if (!getBufferSource(raw, "salt", salt, context, error))
         return false;
-    BufferSource infoBufferSource;
-    if (!getBufferSource(raw, "info", infoBufferSource, context, error))
+    Vector<uint8_t> info;
+    if (!getBufferSource(raw, "info", info, context, error))
         return false;
 
-    DOMArrayPiece salt(saltBufferSource);
-    DOMArrayPiece info(infoBufferSource);
-
-    params = wrapUnique(new WebCryptoHkdfParams(hash, salt.bytes(), salt.byteLength(), info.bytes(), info.byteLength()));
+    params = wrapUnique(new WebCryptoHkdfParams(hash, salt.data(), salt.size(), info.data(), info.size()));
     return true;
 }
 
 bool parseAlgorithmParams(const Dictionary& raw, WebCryptoAlgorithmParamsType type, std::unique_ptr<WebCryptoAlgorithmParams>& params, ErrorContext& context, AlgorithmError* error)
 {
     switch (type) {
     case WebCryptoAlgorithmParamsTypeNone:
         return true;
     case WebCryptoAlgorithmParamsTypeAesCbcParams:
         context.add("AesCbcParams");
@@ skipping 136 matching lines @@
 }
 
 } // namespace
 
 bool normalizeAlgorithm(const AlgorithmIdentifier& raw, WebCryptoOperation op, WebCryptoAlgorithm& algorithm, AlgorithmError* error)
 {
     return parseAlgorithmIdentifier(raw, op, algorithm, ErrorContext(), error);
 }
 
 } // namespace blink