Raise an error when calling WebCrypto's deriveBits() for HKDF with

components/webcrypto/algorithms/hkdf.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 <stdint.h>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithms/secret_key_util.h"
@@ skipping 53 matching lines @@
 
   Status DeriveBits(const blink::WebCryptoAlgorithm& algorithm,
                     const blink::WebCryptoKey& base_key,
                     bool has_optional_length_bits,
                     unsigned int optional_length_bits,
                     std::vector<uint8_t>* derived_bytes) const override {
     crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
     if (!has_optional_length_bits)
       return Status::ErrorHkdfDeriveBitsLengthNotSpecified();
 
+    if (optional_length_bits % 8)
+      return Status::ErrorHkdfLengthNotWholeByte();
+
     const blink::WebCryptoHkdfParams* params = algorithm.HkdfParams();
 
     const EVP_MD* digest_algorithm = GetDigest(params->GetHash());
     if (!digest_algorithm)
       return Status::ErrorUnsupported();
 
     // Size output to fit length
-    unsigned int derived_bytes_len = NumBitsToBytes(optional_length_bits);
+    unsigned int derived_bytes_len = optional_length_bits / 8;
     derived_bytes->resize(derived_bytes_len);
 
     // Algorithm dispatch checks that the algorithm in |base_key| matches
     // |algorithm|.
     const std::vector<uint8_t>& raw_key = GetSymmetricKeyData(base_key);
     if (!HKDF(derived_bytes->data(), derived_bytes_len, digest_algorithm,
               raw_key.data(), raw_key.size(), params->Salt().Data(),
               params->Salt().size(), params->Info().Data(),
               params->Info().size())) {
       uint32_t error = ERR_get_error();
       if (ERR_GET_LIB(error) == ERR_LIB_HKDF &&
           ERR_GET_REASON(error) == HKDF_R_OUTPUT_TOO_LARGE) {
         return Status::ErrorHkdfLengthTooLong();
       }
       return Status::OperationError();
     }
 
-    TruncateToBitLength(optional_length_bits, derived_bytes);
     return Status::Success();
   }
 
   Status DeserializeKeyForClone(const blink::WebCryptoKeyAlgorithm& algorithm,
                                 blink::WebCryptoKeyType type,
                                 bool extractable,
                                 blink::WebCryptoKeyUsageMask usages,
                                 const CryptoData& key_data,
                                 blink::WebCryptoKey* key) const override {
     if (algorithm.ParamsType() != blink::kWebCryptoKeyAlgorithmParamsTypeNone ||
@@ skipping 16 matching lines @@
   }
 };
 
 }  // namespace
 
 std::unique_ptr<AlgorithmImplementation> CreateHkdfImplementation() {
   return base::WrapUnique(new HkdfImplementation);
 }
 
 }  // namespace webcrypto