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 72 matching lines @@
     case WebCryptoKeyAlgorithmParamsTypeHmac:
         doWriteHmacKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeRsaHashed:
         doWriteRsaHashedKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeEc:
         doWriteEcKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeNone:
         ASSERT_NOT_REACHED();

[eroman, 2014/12/23 20:58:24]

This is incomplete. Serialization of HKDF keys is going to fail.

If you are going to be editing this file and introducing the HDKF key type, you
should implement serialization/deserialization too.

[nharper, 2014/12/23 22:46:59]

Can you point me to an example CL that added serialization/deserialization for
an algorithm? I'm not familiar with this part of webcrypto.

[eroman, 2014/12/23 23:34:29]

Example:

https://code.google.com/p/chromium/codesearch#chromium/src/content/child/webc...

You can probably copy paste the code for those 2 functions and remove the params
stuff, and should be good.

[eroman, 2014/12/24 00:38:27]

Given that PBKDF2's key will be exactly the same, can probably invent a format
that will generalize to both (i.e just save the algorithm id maybe?)

I dunno, whatever approach ends up being cleaner.

[nharper, 2015/01/06 21:53:00]

I added a Kdf params type (to be used for both HKDF and PBKDF2)

         return false;
     }
 
     doWriteKeyUsages(key.usages(), key.extractable());
 
     WebVector<uint8_t> keyData;
     if (!Platform::current()->crypto()->serializeKeyForClone(key, keyData))
         return false;
 
     doWriteUint32(keyData.size());
@@ skipping 72 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 272 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