[webcrypto] Add the KeyAlgorithm interface.

Source/modules/crypto/NormalizeAlgorithm.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 82 matching lines @@
 
     // AES-CTR
     {blink::WebCryptoAlgorithmIdAesCtr, Decrypt, blink::WebCryptoAlgorithmParamsTypeAesCtrParams},
     {blink::WebCryptoAlgorithmIdAesCtr, Encrypt, blink::WebCryptoAlgorithmParamsTypeAesCtrParams},
     {blink::WebCryptoAlgorithmIdAesCtr, GenerateKey, blink::WebCryptoAlgorithmParamsTypeAesKeyGenParams},
     {blink::WebCryptoAlgorithmIdAesCtr, ImportKey, blink::WebCryptoAlgorithmParamsTypeNone},
     {blink::WebCryptoAlgorithmIdAesCtr, UnwrapKey, blink::WebCryptoAlgorithmParamsTypeAesCtrParams},
     {blink::WebCryptoAlgorithmIdAesCtr, WrapKey, blink::WebCryptoAlgorithmParamsTypeAesCtrParams},
 
     // HMAC
-    {blink::WebCryptoAlgorithmIdHmac, Sign, blink::WebCryptoAlgorithmParamsTypeHmacParams},
-    {blink::WebCryptoAlgorithmIdHmac, Verify, blink::WebCryptoAlgorithmParamsTypeHmacParams},
-    {blink::WebCryptoAlgorithmIdHmac, GenerateKey, blink::WebCryptoAlgorithmParamsTypeHmacKeyParams},
-    {blink::WebCryptoAlgorithmIdHmac, ImportKey, blink::WebCryptoAlgorithmParamsTypeHmacParams},
+    {blink::WebCryptoAlgorithmIdHmac, Sign, blink::WebCryptoAlgorithmParamsTypeNone},
+    {blink::WebCryptoAlgorithmIdHmac, Verify, blink::WebCryptoAlgorithmParamsTypeNone},
+    {blink::WebCryptoAlgorithmIdHmac, GenerateKey, blink::WebCryptoAlgorithmParamsTypeHmacKeyGenParams},
+    {blink::WebCryptoAlgorithmIdHmac, ImportKey, blink::WebCryptoAlgorithmParamsTypeHmacImportParams},
 
     // RSASSA-PKCS1-v1_5
-    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, Sign, blink::WebCryptoAlgorithmParamsTypeRsaSsaParams},
-    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, Verify, blink::WebCryptoAlgorithmParamsTypeRsaSsaParams},
-    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, GenerateKey, blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams},
-    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, ImportKey, blink::WebCryptoAlgorithmParamsTypeNone},
+    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, Sign, blink::WebCryptoAlgorithmParamsTypeNone},
+    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, Verify, blink::WebCryptoAlgorithmParamsTypeNone},
+    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, GenerateKey, blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams},
+    {blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, ImportKey, blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams},
 
     // RSAES-PKCS1-v1_5
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, Encrypt, blink::WebCryptoAlgorithmParamsTypeNone},
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, Decrypt, blink::WebCryptoAlgorithmParamsTypeNone},
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, GenerateKey, blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams},
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, ImportKey, blink::WebCryptoAlgorithmParamsTypeNone},
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, WrapKey, blink::WebCryptoAlgorithmParamsTypeNone},
     {blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, UnwrapKey, blink::WebCryptoAlgorithmParamsTypeNone},
 
     // SHA-*
@@ skipping 333 matching lines @@
 
     context.add("hash");
     return parseAlgorithm(rawHash, Digest, hash, context, errorDetails);
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary HmacImportParams : Algorithm {
 //      AlgorithmIdentifier hash;
 //    };
-bool parseHmacParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseHmacImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
 {
     blink::WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, errorDetails))
         return false;
 
-    params = adoptPtr(new blink::WebCryptoHmacParams(hash));
+    params = adoptPtr(new blink::WebCryptoHmacImportParams(hash));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary HmacKeyGenParams : Algorithm {
 //      AlgorithmIdentifier hash;
 //      // The length (in bytes) of the key to generate. If unspecified, the
 //      // recommended length will be used, which is the size of the associated hash function's block
 //      // size.
 //      unsigned long length;
 //    };
-bool parseHmacKeyParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseHmacKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
 {
     blink::WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, errorDetails))
         return false;
 
     bool hasLength;
     uint32_t length = 0;
     if (!getOptionalUint32(raw, "length", hasLength, length, context, errorDetails))
         return false;
 
-    params = adoptPtr(new blink::WebCryptoHmacKeyParams(hash, hasLength, length));
+    params = adoptPtr(new blink::WebCryptoHmacKeyGenParams(hash, hasLength, length));
     return true;
 }
 
-bool parseRsaSsaParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+// Defined by the WebCrypto spec as:
+//
+//    dictionary RsaHashedImportParams {
+//      AlgorithmIdentifier hash;
+//    };
+bool parseRsaHashedImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
 {
     blink::WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, errorDetails))
         return false;
 
-    params = adoptPtr(new blink::WebCryptoRsaSsaParams(hash));
+    params = adoptPtr(new blink::WebCryptoRsaHashedImportParams(hash));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary RsaKeyGenParams : Algorithm {
 //      unsigned long modulusLength;
 //      BigInteger publicExponent;
 //    };
+bool parseRsaKeyGenParams(const Dictionary& raw, uint32_t& modulusLength, RefPtr<Uint8Array>& publicExponent, const ErrorContext& context, String& errorDetails)
+{
+    if (!getUint32(raw, "modulusLength", modulusLength, context, errorDetails))
+        return false;
+
+    if (!getBigInteger(raw, "publicExponent", publicExponent, context, errorDetails))
+        return false;
+
+    return true;
+}
+
 bool parseRsaKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
 {
     uint32_t modulusLength;
-    if (!getUint32(raw, "modulusLength", modulusLength, context, errorDetails))
-        return false;
-
     RefPtr<Uint8Array> publicExponent;
-    if (!getBigInteger(raw, "publicExponent", publicExponent, context, errorDetails))
+    if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, errorDetails))
         return false;
 
     params = adoptPtr(new blink::WebCryptoRsaKeyGenParams(modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
+//    dictionary RsaHashedKeyGenParams : RsaKeyGenParams {
+//      AlgorithmIdentifier hash;
+//    };
+bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+{
+    uint32_t modulusLength;
+    RefPtr<Uint8Array> publicExponent;
+    if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, errorDetails))
+        return false;
+
+    blink::WebCryptoAlgorithm hash;
+    if (!parseHash(raw, hash, context, errorDetails))
+        return false;
+
+    params = adoptPtr(new blink::WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
+    return true;
+}
+
+// Defined by the WebCrypto spec as:
+//
 //    dictionary AesCtrParams : Algorithm {
 //      CryptoOperationData counter;
 //      [EnforceRange] octet length;
 //    };
 bool parseAesCtrParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
 {
     RefPtr<ArrayBufferView> counter;
     if (!getCryptoOperationData(raw, "counter", counter, context, errorDetails))
         return false;
 
@@ skipping 42 matching lines @@
 {
     switch (type) {
     case blink::WebCryptoAlgorithmParamsTypeNone:
         return true;
     case blink::WebCryptoAlgorithmParamsTypeAesCbcParams:
         context.add("AesCbcParams");
         return parseAesCbcParams(raw, params, context, errorDetails);
     case blink::WebCryptoAlgorithmParamsTypeAesKeyGenParams:
         context.add("AesKeyGenParams");
         return parseAesKeyGenParams(raw, params, context, errorDetails);
-    case blink::WebCryptoAlgorithmParamsTypeHmacParams:
-        context.add("HmacParams");
-        return parseHmacParams(raw, params, context, errorDetails);
-    case blink::WebCryptoAlgorithmParamsTypeHmacKeyParams:
-        context.add("HmacKeyParams");
-        return parseHmacKeyParams(raw, params, context, errorDetails);
-    case blink::WebCryptoAlgorithmParamsTypeRsaSsaParams:
-        context.add("RsaSSaParams");
-        return parseRsaSsaParams(raw, params, context, errorDetails);
+    case blink::WebCryptoAlgorithmParamsTypeHmacImportParams:
+        context.add("HmacImporParams");
+        return parseHmacImportParams(raw, params, context, errorDetails);
+    case blink::WebCryptoAlgorithmParamsTypeHmacKeyGenParams:
+        context.add("HmacKeyGenParams");
+        return parseHmacKeyGenParams(raw, params, context, errorDetails);
+    case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
+        context.add("RsaHashedKeyGenParams");
+        return parseRsaHashedKeyGenParams(raw, params, context, errorDetails);
+    case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
+        context.add("RsaHashedImportParams");
+        return parseRsaHashedImportParams(raw, params, context, errorDetails);
     case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams:
         context.add("RsaKeyGenParams");
         return parseRsaKeyGenParams(raw, params, context, errorDetails);
     case blink::WebCryptoAlgorithmParamsTypeAesCtrParams:
         context.add("AesCtrParams");
         return parseAesCtrParams(raw, params, context, errorDetails);
     case blink::WebCryptoAlgorithmParamsTypeAesGcmParams:
         context.add("AesGcmParams");
         return parseAesGcmParams(raw, params, context, errorDetails);
     case blink::WebCryptoAlgorithmParamsTypeRsaOaepParams:
@@ skipping 53 matching lines @@
     }
     return true;
 }
 
 const char* algorithmIdToName(blink::WebCryptoAlgorithmId id)
 {
     return AlgorithmRegistry::instance().lookupAlgorithmById(id)->algorithmName;
 }
 
 } // namespace WebCore