Implement HKDF for WebCrypto (blink-side)

Source/bindings/modules/v8/ScriptValueSerializerForModules.cpp

 // 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 "config.h"
 #include "bindings/modules/v8/ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
@@ skipping 12 matching lines @@
     Sha256Tag = 6,
     Sha384Tag = 7,
     Sha512Tag = 8,
     AesGcmTag = 9,
     RsaOaepTag = 10,
     AesCtrTag = 11,
     AesKwTag = 12,
     RsaPssTag = 13,
     EcdsaTag = 14,
     EcdhTag = 15,
+    HkdfTag = 16,
     // Maximum allowed value is 2^32-1
 };
 
 enum NamedCurveTag {
     P256Tag = 1,
     P384Tag = 2,
     P521Tag = 3,
 };
 
 enum CryptoKeyUsage {
@@ skipping 11 matching lines @@
     DeriveBitsUsage = 1 << 8,
     // Maximum allowed value is 1 << 31
 };
 
 enum CryptoKeySubTag {
     AesKeyTag = 1,
     HmacKeyTag = 2,
     // ID 3 was used by RsaKeyTag, while still behind experimental flag.
     RsaHashedKeyTag = 4,
     EcKeyTag = 5,
+    NoParamsKeyTag = 6,
     // Maximum allowed value is 255
 };
 
 enum AssymetricCryptoKeyType {
     PublicKeyType = 1,
     PrivateKeyType = 2,
     // Maximum allowed value is 2^32-1
 };
 
 
@@ skipping 41 matching lines @@
     case WebCryptoKeyAlgorithmParamsTypeHmac:
         doWriteHmacKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeRsaHashed:
         doWriteRsaHashedKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeEc:
         doWriteEcKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeNone:
-        ASSERT_NOT_REACHED();
-        return false;
+        doWriteKeyWithoutParams(key);
+        break;
     }
 
     doWriteKeyUsages(key.usages(), key.extractable());
 
     WebVector<uint8_t> keyData;
     if (!Platform::current()->crypto()->serializeKeyForClone(key, keyData))
         return false;
 
     doWriteUint32(keyData.size());
     append(keyData.data(), keyData.size());
@@ skipping 40 matching lines @@
 void SerializedScriptValueWriterForModules::doWriteEcKey(const WebCryptoKey& key)
 {
     ASSERT(key.algorithm().ecParams());
     append(static_cast<uint8_t>(EcKeyTag));
 
     doWriteAlgorithmId(key.algorithm().id());
     doWriteAsymmetricKeyType(key.type());
     doWriteNamedCurve(key.algorithm().ecParams()->namedCurve());
 }
 
+void SerializedScriptValueWriterForModules::doWriteKeyWithoutParams(const WebCryptoKey& key)
+{
+    ASSERT(WebCryptoAlgorithm::isKdf(key.algorithm().id()));
+    append(static_cast<uint8_t>(NoParamsKeyTag));
+
+    doWriteAlgorithmId(key.algorithm().id());
+}
+
 void SerializedScriptValueWriterForModules::doWriteAlgorithmId(WebCryptoAlgorithmId id)
 {
     switch (id) {
     case WebCryptoAlgorithmIdAesCbc:
         return doWriteUint32(AesCbcTag);
     case WebCryptoAlgorithmIdHmac:
         return doWriteUint32(HmacTag);
     case WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
         return doWriteUint32(RsaSsaPkcs1v1_5Tag);
     case WebCryptoAlgorithmIdSha1:
@@ skipping 11 matching lines @@
     case WebCryptoAlgorithmIdAesCtr:
         return doWriteUint32(AesCtrTag);
     case WebCryptoAlgorithmIdAesKw:
         return doWriteUint32(AesKwTag);
     case WebCryptoAlgorithmIdRsaPss:
         return doWriteUint32(RsaPssTag);
     case WebCryptoAlgorithmIdEcdsa:
         return doWriteUint32(EcdsaTag);
     case WebCryptoAlgorithmIdEcdh:
         return doWriteUint32(EcdhTag);
+    case WebCryptoAlgorithmIdHkdf:
+        return doWriteUint32(HkdfTag);
     }
     ASSERT_NOT_REACHED();
 }
 
 void SerializedScriptValueWriterForModules::doWriteAsymmetricKeyType(WebCryptoKeyType keyType)
 {
     switch (keyType) {
     case WebCryptoKeyTypePublic:
         doWriteUint32(PublicKeyType);
         break;
@@ skipping 124 matching lines @@
             return false;
         break;
     case RsaHashedKeyTag:
         if (!doReadRsaHashedKey(algorithm, type))
             return false;
         break;
     case EcKeyTag:
         if (!doReadEcKey(algorithm, type))
             return false;
         break;
+    case NoParamsKeyTag:
+        if (!doReadKeyWithoutParams(algorithm, type))
+            return false;
+        break;
     default:
         return false;
     }
 
     WebCryptoKeyUsageMask usages;
     bool extractable;
     if (!doReadKeyUsages(usages, extractable))
         return false;
 
     uint32_t keyDataLength;
@@ skipping 79 matching lines @@
         return false;
 
     WebCryptoNamedCurve namedCurve;
     if (!doReadNamedCurve(namedCurve))
         return false;
 
     algorithm = WebCryptoKeyAlgorithm::createEc(id, namedCurve);
     return !algorithm.isNull();
 }
 
+bool SerializedScriptValueReaderForModules::doReadKeyWithoutParams(WebCryptoKeyAlgorithm& algorithm, WebCryptoKeyType& type)
+{
+    WebCryptoAlgorithmId id;
+    if (!doReadAlgorithmId(id))
+        return false;
+    algorithm = WebCryptoKeyAlgorithm::createWithoutParams(id);
+    type = WebCryptoKeyTypeSecret;
+    return !algorithm.isNull();
+}
+
 bool SerializedScriptValueReaderForModules::doReadAlgorithmId(WebCryptoAlgorithmId& id)
 {
     uint32_t rawId;
     if (!doReadUint32(&rawId))
         return false;
 
     switch (static_cast<CryptoKeyAlgorithmTag>(rawId)) {
     case AesCbcTag:
         id = WebCryptoAlgorithmIdAesCbc;
         return true;
@@ skipping 29 matching lines @@
         return true;
     case RsaPssTag:
         id = WebCryptoAlgorithmIdRsaPss;
         return true;
     case EcdsaTag:
         id = WebCryptoAlgorithmIdEcdsa;
         return true;
     case EcdhTag:
         id = WebCryptoAlgorithmIdEcdh;
         return true;
+    case HkdfTag:
+        id = WebCryptoAlgorithmIdHkdf;
+        return true;
     }
 
     return false;
 }
 
 bool SerializedScriptValueReaderForModules::doReadAsymmetricKeyType(WebCryptoKeyType& type)
 {
     uint32_t rawType;
     if (!doReadUint32(&rawType))
         return false;
@@ skipping 73 matching lines @@
     : ScriptValueDeserializer(reader, messagePorts, arrayBufferContents)
 {
 }
 
 bool ScriptValueDeserializerForModules::read(v8::Local<v8::Value>* value)
 {
     return toSerializedScriptValueReaderForModules(reader()).read(value, *this);
 }
 
 } // namespace blink