[webcrypto] Make KeyPair structured clonable.

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 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 19 matching lines @@
 
 #include "config.h"
 #include "bindings/v8/SerializedScriptValue.h"
 
 #include "V8Blob.h"
 #include "V8DOMFileSystem.h"
 #include "V8File.h"
 #include "V8FileList.h"
 #include "V8ImageData.h"
 #include "V8Key.h"
+#include "V8KeyPair.h"
 #include "V8MessagePort.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/WorkerScriptController.h"
 #include "bindings/v8/custom/V8ArrayBufferCustom.h"
 #include "bindings/v8/custom/V8ArrayBufferViewCustom.h"
 #include "bindings/v8/custom/V8DataViewCustom.h"
 #include "bindings/v8/custom/V8Float32ArrayCustom.h"
 #include "bindings/v8/custom/V8Float64ArrayCustom.h"
 #include "bindings/v8/custom/V8Int16ArrayCustom.h"
@@ skipping 168 matching lines @@
     ArrayBufferViewTag = 'V', // subtag:byte, byteOffset:uint32_t, byteLength:uint32_t -> ArrayBufferView (ref). Consumes an ArrayBuffer from the top of the deserialization stack.
     CryptoKeyTag = 'K', // subtag:byte, props, usages:uint32_t, keyDataLength:uint32_t, keyData:byte[keyDataLength]
                         //   If subtag=AesKeyTag:
                         //       props = keyLengthBytes:uint32_t, algorithmId:uint32_t
                         //   If subtag=HmacKeyTag:
                         //       props = keyLengthBytes:uint32_t, hashId:uint32_t
                         //   If subtag=RsaKeyTag:
                         //       props = algorithmId:uint32_t, type:uint32_t, modulusLengthBits:uint32_t, publicExponentLength:uint32_t, publicExponent:byte[publicExponentLength]
                         //   If subtag=RsaHashedKeyTag:
                         //       props = <same as for RsaKeyTag>, hashId:uint32_t
+    CryptoKeyPairTag = 'k', // publicKey:CryptoKey, privateKey:CryptoKey
     ObjectReferenceTag = '^', // ref:uint32_t -> reference table[ref]
     GenerateFreshObjectTag = 'o', // -> empty object allocated an object ID and pushed onto the open stack (ref)
     GenerateFreshSparseArrayTag = 'a', // length:uint32_t -> empty array[length] allocated an object ID and pushed onto the open stack (ref)
     GenerateFreshDenseArrayTag = 'A', // length:uint32_t -> empty array[length] allocated an object ID and pushed onto the open stack (ref)
     ReferenceCountTag = '?', // refTableSize:uint32_t -> If the reference table is not refTableSize big, fails.
     StringObjectTag = 's', //  string:RawString -> new String(string) (ref)
     NumberObjectTag = 'n', // value:double -> new Number(value) (ref)
     TrueObjectTag = 'y', // new Boolean(true) (ref)
     FalseObjectTag = 'x', // new Boolean(false) (ref)
     VersionTag = 0xFF // version:uint32_t -> Uses this as the file version.
@@ skipping 261 matching lines @@
 
     void writeFileListIndex(const Vector<int>& blobIndices)
     {
         append(FileListIndexTag);
         uint32_t length = blobIndices.size();
         doWriteUint32(length);
         for (unsigned i = 0; i < length; ++i)
             doWriteUint32(blobIndices[i]);
     }
 
-    bool writeCryptoKey(const blink::WebCryptoKey& key)
+    bool writeCryptoKey(const blink::WebCryptoKey& key, bool includeTag)
     {
-        append(static_cast<uint8_t>(CryptoKeyTag));
+        if (includeTag)
+            append(static_cast<uint8_t>(CryptoKeyTag));
 
         switch (key.algorithm().paramsType()) {
         case blink::WebCryptoKeyAlgorithmParamsTypeAes:
             doWriteAesKey(key);
             break;
         case blink::WebCryptoKeyAlgorithmParamsTypeHmac:
             doWriteHmacKey(key);
             break;
         case blink::WebCryptoKeyAlgorithmParamsTypeRsa:
         case blink::WebCryptoKeyAlgorithmParamsTypeRsaHashed:
             doWriteRsaKey(key);
             break;
         case blink::WebCryptoKeyAlgorithmParamsTypeNone:
             ASSERT_NOT_REACHED();
             return false;
         }
 
         doWriteKeyUsages(key.usages(), key.extractable());
 
         blink::WebVector<uint8_t> keyData;
         if (!blink::Platform::current()->crypto()->serializeKeyForClone(key, keyData))
             return false;
 
         doWriteUint32(keyData.size());
         append(keyData.data(), keyData.size());
         return true;
     }
 
+    bool writeCryptoKeyPair(const blink::WebCryptoKey& publicKey, const blink::WebCryptoKey& privateKey)
+    {
+        append(static_cast<uint8_t>(CryptoKeyPairTag));
+        return writeCryptoKey(publicKey, false) && writeCryptoKey(privateKey, false);
+    }
+
     void writeArrayBuffer(const ArrayBuffer& arrayBuffer)
     {
         append(ArrayBufferTag);
         doWriteArrayBuffer(arrayBuffer);
     }
 
     void writeArrayBufferView(const ArrayBufferView& arrayBufferView)
     {
         append(ArrayBufferViewTag);
 #ifndef NDEBUG
@@ skipping 798 matching lines @@
             m_writer.writeFileListIndex(blobIndices);
         else
             m_writer.writeFileList(*fileList);
         return 0;
     }
 
     bool writeCryptoKey(v8::Handle<v8::Value> value)
     {
         Key* key = V8Key::toNative(value.As<v8::Object>());
         if (!key)
-            return 0;
-        return m_writer.writeCryptoKey(key->key());
+            return false;
+        return m_writer.writeCryptoKey(key->key(), true);
+    }
+
+    bool writeCryptoKeyPair(v8::Handle<v8::Value> value)
+    {
+        KeyPair* keyPair = V8KeyPair::toNative(value.As<v8::Object>());
+        if (!keyPair)
+            return false;
+        return m_writer.writeCryptoKeyPair(keyPair->publicKey()->key(), keyPair->privateKey()->key());
     }
 
     void writeImageData(v8::Handle<v8::Value> value)
     {
         ImageData* imageData = V8ImageData::toNative(value.As<v8::Object>());
         if (!imageData)
             return;
         Uint8ClampedArray* pixelArray = imageData->data();
         m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
     }
@@ skipping 199 matching lines @@
             return writeFile(value, next);
         else if (V8Blob::hasInstance(value, m_isolate))
             return writeBlob(value, next);
         else if (V8DOMFileSystem::hasInstance(value, m_isolate))
             return writeDOMFileSystem(value, next);
         else if (V8FileList::hasInstance(value, m_isolate))
             return writeFileList(value, next);
         else if (V8Key::hasInstance(value, m_isolate)) {
             if (!writeCryptoKey(value))
                 return handleError(DataCloneError, "Couldn't serialize key data", next);
+        } else if (V8KeyPair::hasInstance(value, m_isolate)) {
+            if (!writeCryptoKeyPair(value))
+                return handleError(DataCloneError, "Couldn't serialize key data", next);
         } else if (V8ImageData::hasInstance(value, m_isolate))
             writeImageData(value);
         else if (value->IsRegExp())
             writeRegExp(value);
         else if (V8ArrayBuffer::hasInstance(value, m_isolate))
             return writeArrayBuffer(value, next);
         else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
                 return handleError(DataCloneError, "An object could not be cloned.", next);
             return startObjectState(jsObject, next);
@@ skipping 142 matching lines @@
         case FileListIndexTag:
             if (!readFileList(value, tag == FileListIndexTag))
                 return false;
             creator.pushObjectReference(*value);
             break;
         case CryptoKeyTag:
             if (!readCryptoKey(value))
                 return false;
             creator.pushObjectReference(*value);
             break;
+        case CryptoKeyPairTag:
+            if (!readCryptoKeyPair(value))
+                return false;
+            creator.pushObjectReference(*value);
+            break;
         case ImageDataTag:
             if (!readImageData(value))
                 return false;
             creator.pushObjectReference(*value);
             break;
 
         case RegExpTag:
             if (!readRegExp(value))
                 return false;
             creator.pushObjectReference(*value);
@@ skipping 473 matching lines @@
             if (!file)
                 return false;
             fileList->append(file.release());
         }
         *value = toV8(fileList.release(), v8::Handle<v8::Object>(), m_isolate);
         return true;
     }
 
     bool readCryptoKey(v8::Handle<v8::Value>* value)
     {
+        blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+        if (!readCryptoKey(key))
+            return false;
+
+        *value = toV8(Key::create(key), v8::Handle<v8::Object>(), m_isolate);
+        return true;
+    }
+
+    bool readCryptoKey(blink::WebCryptoKey& key)
+    {
         uint32_t rawKeyType;
         if (!doReadUint32(&rawKeyType))
             return false;
 
         blink::WebCryptoKeyAlgorithm algorithm;
         blink::WebCryptoKeyType type;
 
         switch (static_cast<CryptoKeySubTag>(rawKeyType)) {
         case AesKeyTag:
             if (!doReadAesKey(algorithm, type))
@@ skipping 23 matching lines @@
         uint32_t keyDataLength;
         if (!doReadUint32(&keyDataLength))
             return false;
 
         if (m_position + keyDataLength > m_length)
             return false;
 
         const uint8_t* keyData = m_buffer + m_position;
         m_position += keyDataLength;
 
-        blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
         if (!blink::Platform::current()->crypto()->deserializeKeyForClone(
             algorithm, type, extractable, usages, keyData, keyDataLength, key)) {
             return false;
         }
 
-        *value = toV8(Key::create(key), v8::Handle<v8::Object>(), m_isolate);
         return true;
     }
 
+    bool readCryptoKeyPair(v8::Handle<v8::Value>* value)
+    {
+        blink::WebCryptoKey publicKey = blink::WebCryptoKey::createNull();
+        blink::WebCryptoKey privateKey = blink::WebCryptoKey::createNull();
+
+        if (!readCryptoKey(publicKey) || publicKey.type() != blink::WebCryptoKeyTypePublic)
+            return false;
+        if (!readCryptoKey(privateKey) || privateKey.type() != blink::WebCryptoKeyTypePrivate)
+            return false;
+
+        *value = toV8(KeyPair::create(publicKey, privateKey), v8::Handle<v8::Object>(), m_isolate);
+        return true;
+    }
+
     PassRefPtrWillBeRawPtr<File> readFileHelper()
     {
         if (m_version < 3)
             return nullptr;
         ASSERT(!m_blobInfo);
         String path;
         String name;
         String relativePath;
         String uuid;
         String type;
@@ skipping 761 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace WebCore