WebCrypto: Add crypto.subtle.verify() to the platform interfaces.

Source/modules/crypto/SubtleCrypto.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 83 matching lines @@
     // algorithm.
 
     if (key.algorithm().paramsType() == WebKit::WebCryptoAlgorithmParamsTypeHmacParams) {
         return key.algorithm().hmacParams()->hash().id() == algorithm.hmacParams()->hash().id();
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-PassRefPtr<CryptoOperation> createCryptoOperation(const Dictionary& rawAlgorithm, Key* key, AlgorithmOperation operationType, ExceptionState& es)
+PassRefPtr<CryptoOperation> createCryptoOperation(const Dictionary& rawAlgorithm, Key* key, AlgorithmOperation operationType, ArrayBufferView* signature, ExceptionState& es)
 {
     WebKit::WebCrypto* platformCrypto = WebKit::Platform::current()->crypto();
     if (!platformCrypto) {
         es.throwDOMException(NotSupportedError);
         return 0;
     }
 
     WebKit::WebCryptoAlgorithm algorithm;
     if (!normalizeAlgorithm(rawAlgorithm, operationType, algorithm, es))
         return 0;
 
     // All operations other than Digest require a valid Key.
     if (operationType != Digest) {
         if (!key) {
             es.throwDOMException(TypeError);
             return 0;
         }
 
         if (!keyCanBeUsedForAlgorithm(key->key(), algorithm, operationType)) {
             es.throwDOMException(NotSupportedError);
             return 0;
         }
     }
 
+    // Only Verify takes a signature.
+    if (operationType == Verify && !signature) {
+        es.throwDOMException(TypeError);
+        return 0;
+    }
+
     RefPtr<CryptoOperationImpl> opImpl = CryptoOperationImpl::create();
     WebKit::WebCryptoOperationResult result(opImpl.get());
 
     switch (operationType) {
     case Encrypt:
         platformCrypto->encrypt(algorithm, key->key(), result);
         break;
     case Decrypt:
         platformCrypto->decrypt(algorithm, key->key(), result);
         break;
     case Sign:
         platformCrypto->sign(algorithm, key->key(), result);
         break;
+    case Verify:
+        platformCrypto->verifySignature(algorithm, key->key(), reinterpret_cast<const unsigned char*>(signature->baseAddress()), signature->byteLength(), result);
+        break;
     case Digest:
         platformCrypto->digest(algorithm, result);
         break;
     default:
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     if (opImpl->throwInitializationError(es))
         return 0;
     return CryptoOperation::create(algorithm, opImpl.get());
 }
 
 } // namespace
 
 SubtleCrypto::SubtleCrypto()
 {
     ScriptWrappable::init(this);
 }
 
 PassRefPtr<CryptoOperation> SubtleCrypto::encrypt(const Dictionary& rawAlgorithm, Key* key, ExceptionState& es)
 {
-    return createCryptoOperation(rawAlgorithm, key, Encrypt, es);
+    return createCryptoOperation(rawAlgorithm, key, Encrypt, 0, es);
 }
 
 PassRefPtr<CryptoOperation> SubtleCrypto::decrypt(const Dictionary& rawAlgorithm, Key* key, ExceptionState& es)
 {
-    return createCryptoOperation(rawAlgorithm, key, Decrypt, es);
+    return createCryptoOperation(rawAlgorithm, key, Decrypt, 0, es);
 }
 
 PassRefPtr<CryptoOperation> SubtleCrypto::sign(const Dictionary& rawAlgorithm, Key* key, ExceptionState& es)
 {
-    return createCryptoOperation(rawAlgorithm, key, Sign, es);
+    return createCryptoOperation(rawAlgorithm, key, Sign, 0, es);
 }
 
-PassRefPtr<CryptoOperation> SubtleCrypto::verifySignature(const Dictionary& rawAlgorithm, Key* key, ExceptionState& es)
+PassRefPtr<CryptoOperation> SubtleCrypto::verifySignature(const Dictionary& rawAlgorithm, Key* key, ArrayBufferView* signature, ExceptionState& es)
 {
-    // FIXME
-    return 0;
+    return createCryptoOperation(rawAlgorithm, key, Verify, signature, es);
 }
 
 PassRefPtr<CryptoOperation> SubtleCrypto::digest(const Dictionary& rawAlgorithm, ExceptionState& es)
 {
-    return createCryptoOperation(rawAlgorithm, 0, Digest, es);
+    return createCryptoOperation(rawAlgorithm, 0, Digest, 0, es);
 }
 
 ScriptObject SubtleCrypto::importKey(const String& rawFormat, ArrayBufferView* keyData, const Dictionary& rawAlgorithm, bool extractable, const Vector<String>& rawKeyUsages, ExceptionState& es)
 {
     WebKit::WebCrypto* platformCrypto = WebKit::Platform::current()->crypto();
     if (!platformCrypto) {
         es.throwDOMException(NotSupportedError);
         return ScriptObject();
     }
 
@@ skipping 20 matching lines @@
 
     const unsigned char* keyDataBytes = static_cast<unsigned char*>(keyData->baseAddress());
 
     RefPtr<KeyOperation> keyOp = KeyOperation::create();
     WebKit::WebCryptoKeyOperationResult result(keyOp.get());
     platformCrypto->importKey(format, keyDataBytes, keyData->byteLength(), algorithm, extractable, keyUsages, result);
     return keyOp->returnValue(es);
 }
 
 } // namespace WebCore