Unreviewed, rolling out r159160, r159161, and r159164.
[WebKit-https.git] / Source / WebCore / bindings / js / JSCryptoAlgorithmDictionary.cpp
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "JSCryptoAlgorithmDictionary.h"
28
29 #if ENABLE(SUBTLE_CRYPTO)
30
31 #include "CryptoAlgorithmAesCbcParams.h"
32 #include "CryptoAlgorithmAesKeyGenParams.h"
33 #include "CryptoAlgorithmHmacKeyParams.h"
34 #include "CryptoAlgorithmHmacParams.h"
35 #include "CryptoAlgorithmRegistry.h"
36 #include "ExceptionCode.h"
37 #include "JSCryptoOperationData.h"
38 #include "JSDOMBinding.h"
39 #include "JSDictionary.h"
40
41 using namespace JSC;
42
43 namespace WebCore {
44
45 bool JSCryptoAlgorithmDictionary::getAlgorithmIdentifier(ExecState* exec, JSValue value, CryptoAlgorithmIdentifier& algorithmIdentifier)
46 {
47     // typedef (Algorithm or DOMString) AlgorithmIdentifier;
48
49     String algorithmName;
50
51     if (value.isString())
52         algorithmName = value.toString(exec)->value(exec);
53     else if (value.isObject()) {
54         if (value.getObject()->inherits(StringObject::info()))
55             algorithmName = asString(asStringObject(value)->internalValue())->value(exec);
56         else {
57             // FIXME: This doesn't perform some checks mandated by WebIDL for dictionaries:
58             // - null and undefined input should be treated as if all elements in the dictionary were undefined;
59             // - undefined elements should be treated as having a default value, or as not present if there isn't such;
60             // - RegExp and Date objects cannot be converted to dictionaries.
61             //
62             // This is partially because we don't implement it elsewhere in WebCore yet, and partially because
63             // WebCrypto doesn't yet clearly specify what to do with non-present values in most cases anyway.
64
65             JSDictionary dictionary(exec, value.getObject());
66             dictionary.get("name", algorithmName);
67         }
68     }
69
70     if (exec->hadException())
71         return false;
72
73     if (!algorithmName.containsOnlyASCII()) {
74         throwSyntaxError(exec);
75         return false;
76     }
77
78     if (!CryptoAlgorithmRegistry::shared().getIdentifierForName(algorithmName, algorithmIdentifier)) {
79         setDOMException(exec, NOT_SUPPORTED_ERR);
80         return false;
81     }
82
83     return true;
84 }
85
86 static JSValue getProperty(ExecState* exec, JSObject* object, const char* name)
87 {
88     Identifier identifier(exec, name);
89     PropertySlot slot(object);
90
91     if (object->getPropertySlot(exec, identifier, slot))
92         return slot.getValue(exec, identifier);
93
94     return jsUndefined();
95 }
96
97 static bool getHashAlgorithm(JSDictionary& dictionary, CryptoAlgorithmIdentifier& result)
98 {
99     // FXIME: Teach JSDictionary how to return JSValues, and use that to get hash element value.
100
101     ExecState* exec = dictionary.execState();
102     JSObject* object = dictionary.initializerObject();
103
104     Identifier identifier(exec, "hash");
105     PropertySlot slot(object);
106
107     JSValue hash = getProperty(exec, object, "hash");
108     if (exec->hadException())
109         return false;
110
111     if (hash.isUndefinedOrNull()) {
112         setDOMException(exec, NOT_SUPPORTED_ERR);
113         return false;
114     }
115
116     return JSCryptoAlgorithmDictionary::getAlgorithmIdentifier(exec, hash, result);
117 }
118
119 static std::unique_ptr<CryptoAlgorithmParameters> createAesCbcParams(JSC::ExecState* exec, JSC::JSValue value)
120 {
121     if (!value.isObject()) {
122         throwTypeError(exec);
123         return nullptr;
124     }
125
126     JSValue iv = getProperty(exec, value.getObject(), "iv");
127     if (exec->hadException())
128         return nullptr;
129
130     auto result = std::make_unique<CryptoAlgorithmAesCbcParams>();
131
132     CryptoOperationData ivData;
133     if (!cryptoOperationDataFromJSValue(exec, iv, ivData)) {
134         ASSERT(exec->hadException());
135         return nullptr;
136     }
137
138     if (ivData.second != 16) {
139         exec->vm().throwException(exec, createError(exec, "AES-CBC initialization data must be 16 bytes"));
140         return nullptr;
141     }
142
143     memcpy(result->iv.data(), ivData.first, ivData.second);
144
145     return std::move(result);
146 }
147
148 static std::unique_ptr<CryptoAlgorithmParameters> createAesKeyGenParams(JSC::ExecState* exec, JSC::JSValue value)
149 {
150     if (!value.isObject()) {
151         throwTypeError(exec);
152         return nullptr;
153     }
154
155     auto result = std::make_unique<CryptoAlgorithmAesKeyGenParams>();
156
157     JSValue lengthValue = getProperty(exec, value.getObject(), "length");
158     if (exec->hadException())
159         return nullptr;
160
161     result->length = toUInt16(exec, lengthValue, EnforceRange);
162
163     return std::move(result);
164 }
165
166 static std::unique_ptr<CryptoAlgorithmParameters> createHmacParams(JSC::ExecState* exec, JSC::JSValue value)
167 {
168     if (!value.isObject()) {
169         throwTypeError(exec);
170         return nullptr;
171     }
172
173     JSDictionary jsDictionary(exec, value.getObject());
174     auto result = std::make_unique<CryptoAlgorithmHmacParams>();
175
176     if (!getHashAlgorithm(jsDictionary, result->hash)) {
177         ASSERT(exec->hadException());
178         return nullptr;
179     }
180
181     return std::move(result);
182 }
183
184 static std::unique_ptr<CryptoAlgorithmParameters> createHmacKeyParams(JSC::ExecState* exec, JSC::JSValue value)
185 {
186     if (!value.isObject()) {
187         throwTypeError(exec);
188         return nullptr;
189     }
190
191     JSDictionary jsDictionary(exec, value.getObject());
192     auto result = std::make_unique<CryptoAlgorithmHmacKeyParams>();
193
194     if (!getHashAlgorithm(jsDictionary, result->hash)) {
195         ASSERT(exec->hadException());
196         return nullptr;
197     }
198
199     result->hasLength = jsDictionary.get("length", result->length);
200     if (exec->hadException())
201         return nullptr;
202
203     return std::move(result);
204 }
205
206 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForEncrypt(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
207 {
208     switch (algorithm) {
209     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
210     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
211     case CryptoAlgorithmIdentifier::RSA_PSS:
212     case CryptoAlgorithmIdentifier::RSA_OAEP:
213     case CryptoAlgorithmIdentifier::ECDSA:
214     case CryptoAlgorithmIdentifier::ECDH:
215     case CryptoAlgorithmIdentifier::AES_CTR:
216         setDOMException(exec, NOT_SUPPORTED_ERR);
217         return nullptr;
218     case CryptoAlgorithmIdentifier::AES_CBC:
219         return createAesCbcParams(exec, value);
220     case CryptoAlgorithmIdentifier::AES_CMAC:
221     case CryptoAlgorithmIdentifier::AES_GCM:
222     case CryptoAlgorithmIdentifier::AES_CFB:
223     case CryptoAlgorithmIdentifier::HMAC:
224     case CryptoAlgorithmIdentifier::DH:
225     case CryptoAlgorithmIdentifier::SHA_1:
226     case CryptoAlgorithmIdentifier::SHA_224:
227     case CryptoAlgorithmIdentifier::SHA_256:
228     case CryptoAlgorithmIdentifier::SHA_384:
229     case CryptoAlgorithmIdentifier::SHA_512:
230     case CryptoAlgorithmIdentifier::CONCAT:
231     case CryptoAlgorithmIdentifier::HKDF_CTR:
232     case CryptoAlgorithmIdentifier::PBKDF2:
233         setDOMException(exec, NOT_SUPPORTED_ERR);
234         return nullptr;
235     }
236 }
237
238 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDecrypt(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
239 {
240     switch (algorithm) {
241     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
242     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
243     case CryptoAlgorithmIdentifier::RSA_PSS:
244     case CryptoAlgorithmIdentifier::RSA_OAEP:
245     case CryptoAlgorithmIdentifier::ECDSA:
246     case CryptoAlgorithmIdentifier::ECDH:
247     case CryptoAlgorithmIdentifier::AES_CTR:
248         setDOMException(exec, NOT_SUPPORTED_ERR);
249         return nullptr;
250     case CryptoAlgorithmIdentifier::AES_CBC:
251         return createAesCbcParams(exec, value);
252     case CryptoAlgorithmIdentifier::AES_CMAC:
253     case CryptoAlgorithmIdentifier::AES_GCM:
254     case CryptoAlgorithmIdentifier::AES_CFB:
255     case CryptoAlgorithmIdentifier::HMAC:
256     case CryptoAlgorithmIdentifier::DH:
257     case CryptoAlgorithmIdentifier::SHA_1:
258     case CryptoAlgorithmIdentifier::SHA_224:
259     case CryptoAlgorithmIdentifier::SHA_256:
260     case CryptoAlgorithmIdentifier::SHA_384:
261     case CryptoAlgorithmIdentifier::SHA_512:
262     case CryptoAlgorithmIdentifier::CONCAT:
263     case CryptoAlgorithmIdentifier::HKDF_CTR:
264     case CryptoAlgorithmIdentifier::PBKDF2:
265         setDOMException(exec, NOT_SUPPORTED_ERR);
266         return nullptr;
267     }
268 }
269
270 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForSign(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
271 {
272     switch (algorithm) {
273     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
274     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
275     case CryptoAlgorithmIdentifier::RSA_PSS:
276     case CryptoAlgorithmIdentifier::RSA_OAEP:
277     case CryptoAlgorithmIdentifier::ECDSA:
278     case CryptoAlgorithmIdentifier::ECDH:
279     case CryptoAlgorithmIdentifier::AES_CTR:
280     case CryptoAlgorithmIdentifier::AES_CBC:
281     case CryptoAlgorithmIdentifier::AES_CMAC:
282     case CryptoAlgorithmIdentifier::AES_GCM:
283     case CryptoAlgorithmIdentifier::AES_CFB:
284         setDOMException(exec, NOT_SUPPORTED_ERR);
285         return nullptr;
286     case CryptoAlgorithmIdentifier::HMAC:
287         return createHmacParams(exec, value);
288     case CryptoAlgorithmIdentifier::DH:
289     case CryptoAlgorithmIdentifier::SHA_1:
290     case CryptoAlgorithmIdentifier::SHA_224:
291     case CryptoAlgorithmIdentifier::SHA_256:
292     case CryptoAlgorithmIdentifier::SHA_384:
293     case CryptoAlgorithmIdentifier::SHA_512:
294     case CryptoAlgorithmIdentifier::CONCAT:
295     case CryptoAlgorithmIdentifier::HKDF_CTR:
296     case CryptoAlgorithmIdentifier::PBKDF2:
297         setDOMException(exec, NOT_SUPPORTED_ERR);
298         return nullptr;
299     }
300 }
301
302 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForVerify(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
303 {
304     switch (algorithm) {
305     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
306     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
307     case CryptoAlgorithmIdentifier::RSA_PSS:
308     case CryptoAlgorithmIdentifier::RSA_OAEP:
309     case CryptoAlgorithmIdentifier::ECDSA:
310     case CryptoAlgorithmIdentifier::ECDH:
311     case CryptoAlgorithmIdentifier::AES_CTR:
312     case CryptoAlgorithmIdentifier::AES_CBC:
313     case CryptoAlgorithmIdentifier::AES_CMAC:
314     case CryptoAlgorithmIdentifier::AES_GCM:
315     case CryptoAlgorithmIdentifier::AES_CFB:
316         setDOMException(exec, NOT_SUPPORTED_ERR);
317         return nullptr;
318     case CryptoAlgorithmIdentifier::HMAC:
319         return createHmacParams(exec, value);
320     case CryptoAlgorithmIdentifier::DH:
321     case CryptoAlgorithmIdentifier::SHA_1:
322     case CryptoAlgorithmIdentifier::SHA_224:
323     case CryptoAlgorithmIdentifier::SHA_256:
324     case CryptoAlgorithmIdentifier::SHA_384:
325     case CryptoAlgorithmIdentifier::SHA_512:
326     case CryptoAlgorithmIdentifier::CONCAT:
327     case CryptoAlgorithmIdentifier::HKDF_CTR:
328     case CryptoAlgorithmIdentifier::PBKDF2:
329         setDOMException(exec, NOT_SUPPORTED_ERR);
330         return nullptr;
331     }
332 }
333
334 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDigest(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
335 {
336     switch (algorithm) {
337     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
338     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
339     case CryptoAlgorithmIdentifier::RSA_PSS:
340     case CryptoAlgorithmIdentifier::RSA_OAEP:
341     case CryptoAlgorithmIdentifier::ECDSA:
342     case CryptoAlgorithmIdentifier::ECDH:
343     case CryptoAlgorithmIdentifier::AES_CTR:
344     case CryptoAlgorithmIdentifier::AES_CBC:
345     case CryptoAlgorithmIdentifier::AES_CMAC:
346     case CryptoAlgorithmIdentifier::AES_GCM:
347     case CryptoAlgorithmIdentifier::AES_CFB:
348     case CryptoAlgorithmIdentifier::HMAC:
349     case CryptoAlgorithmIdentifier::DH:
350         setDOMException(exec, NOT_SUPPORTED_ERR);
351         return nullptr;
352     case CryptoAlgorithmIdentifier::SHA_1:
353     case CryptoAlgorithmIdentifier::SHA_224:
354     case CryptoAlgorithmIdentifier::SHA_256:
355     case CryptoAlgorithmIdentifier::SHA_384:
356     case CryptoAlgorithmIdentifier::SHA_512:
357         return std::make_unique<CryptoAlgorithmParameters>();
358     case CryptoAlgorithmIdentifier::CONCAT:
359     case CryptoAlgorithmIdentifier::HKDF_CTR:
360     case CryptoAlgorithmIdentifier::PBKDF2:
361         setDOMException(exec, NOT_SUPPORTED_ERR);
362         return nullptr;
363     }
364 }
365
366 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForGenerateKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
367 {
368     switch (algorithm) {
369     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
370     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
371     case CryptoAlgorithmIdentifier::RSA_PSS:
372     case CryptoAlgorithmIdentifier::RSA_OAEP:
373     case CryptoAlgorithmIdentifier::ECDSA:
374     case CryptoAlgorithmIdentifier::ECDH:
375         setDOMException(exec, NOT_SUPPORTED_ERR);
376         return nullptr;
377     case CryptoAlgorithmIdentifier::AES_CTR:
378     case CryptoAlgorithmIdentifier::AES_CBC:
379     case CryptoAlgorithmIdentifier::AES_CMAC:
380     case CryptoAlgorithmIdentifier::AES_GCM:
381     case CryptoAlgorithmIdentifier::AES_CFB:
382         return createAesKeyGenParams(exec, value);
383     case CryptoAlgorithmIdentifier::HMAC:
384         return createHmacKeyParams(exec, value);
385     case CryptoAlgorithmIdentifier::DH:
386     case CryptoAlgorithmIdentifier::SHA_1:
387     case CryptoAlgorithmIdentifier::SHA_224:
388     case CryptoAlgorithmIdentifier::SHA_256:
389     case CryptoAlgorithmIdentifier::SHA_384:
390     case CryptoAlgorithmIdentifier::SHA_512:
391     case CryptoAlgorithmIdentifier::CONCAT:
392     case CryptoAlgorithmIdentifier::HKDF_CTR:
393     case CryptoAlgorithmIdentifier::PBKDF2:
394         setDOMException(exec, NOT_SUPPORTED_ERR);
395         return nullptr;
396     }
397 }
398
399 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDeriveKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
400 {
401     switch (algorithm) {
402     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
403     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
404     case CryptoAlgorithmIdentifier::RSA_PSS:
405     case CryptoAlgorithmIdentifier::RSA_OAEP:
406     case CryptoAlgorithmIdentifier::ECDSA:
407     case CryptoAlgorithmIdentifier::ECDH:
408     case CryptoAlgorithmIdentifier::AES_CTR:
409     case CryptoAlgorithmIdentifier::AES_CBC:
410     case CryptoAlgorithmIdentifier::AES_CMAC:
411     case CryptoAlgorithmIdentifier::AES_GCM:
412     case CryptoAlgorithmIdentifier::AES_CFB:
413     case CryptoAlgorithmIdentifier::HMAC:
414     case CryptoAlgorithmIdentifier::DH:
415     case CryptoAlgorithmIdentifier::SHA_1:
416     case CryptoAlgorithmIdentifier::SHA_224:
417     case CryptoAlgorithmIdentifier::SHA_256:
418     case CryptoAlgorithmIdentifier::SHA_384:
419     case CryptoAlgorithmIdentifier::SHA_512:
420     case CryptoAlgorithmIdentifier::CONCAT:
421     case CryptoAlgorithmIdentifier::HKDF_CTR:
422     case CryptoAlgorithmIdentifier::PBKDF2:
423         setDOMException(exec, NOT_SUPPORTED_ERR);
424         return nullptr;
425     }
426 }
427
428 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDeriveBits(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
429 {
430     switch (algorithm) {
431     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
432     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
433     case CryptoAlgorithmIdentifier::RSA_PSS:
434     case CryptoAlgorithmIdentifier::RSA_OAEP:
435     case CryptoAlgorithmIdentifier::ECDSA:
436     case CryptoAlgorithmIdentifier::ECDH:
437     case CryptoAlgorithmIdentifier::AES_CTR:
438     case CryptoAlgorithmIdentifier::AES_CBC:
439     case CryptoAlgorithmIdentifier::AES_CMAC:
440     case CryptoAlgorithmIdentifier::AES_GCM:
441     case CryptoAlgorithmIdentifier::AES_CFB:
442     case CryptoAlgorithmIdentifier::HMAC:
443     case CryptoAlgorithmIdentifier::DH:
444     case CryptoAlgorithmIdentifier::SHA_1:
445     case CryptoAlgorithmIdentifier::SHA_224:
446     case CryptoAlgorithmIdentifier::SHA_256:
447     case CryptoAlgorithmIdentifier::SHA_384:
448     case CryptoAlgorithmIdentifier::SHA_512:
449     case CryptoAlgorithmIdentifier::CONCAT:
450     case CryptoAlgorithmIdentifier::HKDF_CTR:
451     case CryptoAlgorithmIdentifier::PBKDF2:
452         setDOMException(exec, NOT_SUPPORTED_ERR);
453         return nullptr;
454     }
455 }
456
457 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForImportKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue value)
458 {
459     switch (algorithm) {
460     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
461     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
462     case CryptoAlgorithmIdentifier::RSA_PSS:
463     case CryptoAlgorithmIdentifier::RSA_OAEP:
464     case CryptoAlgorithmIdentifier::ECDSA:
465     case CryptoAlgorithmIdentifier::ECDH:
466     case CryptoAlgorithmIdentifier::AES_CTR:
467     case CryptoAlgorithmIdentifier::AES_CBC:
468     case CryptoAlgorithmIdentifier::AES_CMAC:
469     case CryptoAlgorithmIdentifier::AES_GCM:
470     case CryptoAlgorithmIdentifier::AES_CFB:
471         return std::make_unique<CryptoAlgorithmParameters>();
472     case CryptoAlgorithmIdentifier::HMAC:
473         return createHmacKeyParams(exec, value);
474     case CryptoAlgorithmIdentifier::DH:
475         return std::make_unique<CryptoAlgorithmParameters>();
476     case CryptoAlgorithmIdentifier::SHA_1:
477     case CryptoAlgorithmIdentifier::SHA_224:
478     case CryptoAlgorithmIdentifier::SHA_256:
479     case CryptoAlgorithmIdentifier::SHA_384:
480     case CryptoAlgorithmIdentifier::SHA_512:
481     case CryptoAlgorithmIdentifier::CONCAT:
482     case CryptoAlgorithmIdentifier::HKDF_CTR:
483     case CryptoAlgorithmIdentifier::PBKDF2:
484         setDOMException(exec, NOT_SUPPORTED_ERR);
485         return nullptr;
486     }
487 }
488
489 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForExportKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
490 {
491     switch (algorithm) {
492     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
493     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
494     case CryptoAlgorithmIdentifier::RSA_PSS:
495     case CryptoAlgorithmIdentifier::RSA_OAEP:
496     case CryptoAlgorithmIdentifier::ECDSA:
497     case CryptoAlgorithmIdentifier::ECDH:
498     case CryptoAlgorithmIdentifier::AES_CTR:
499     case CryptoAlgorithmIdentifier::AES_CBC:
500     case CryptoAlgorithmIdentifier::AES_CMAC:
501     case CryptoAlgorithmIdentifier::AES_GCM:
502     case CryptoAlgorithmIdentifier::AES_CFB:
503     case CryptoAlgorithmIdentifier::HMAC:
504     case CryptoAlgorithmIdentifier::DH:
505         return std::make_unique<CryptoAlgorithmParameters>();
506     case CryptoAlgorithmIdentifier::SHA_1:
507     case CryptoAlgorithmIdentifier::SHA_224:
508     case CryptoAlgorithmIdentifier::SHA_256:
509     case CryptoAlgorithmIdentifier::SHA_384:
510     case CryptoAlgorithmIdentifier::SHA_512:
511     case CryptoAlgorithmIdentifier::CONCAT:
512     case CryptoAlgorithmIdentifier::HKDF_CTR:
513     case CryptoAlgorithmIdentifier::PBKDF2:
514         setDOMException(exec, NOT_SUPPORTED_ERR);
515         return nullptr;
516     }
517 }
518
519 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForWrapKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
520 {
521     switch (algorithm) {
522     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
523     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
524     case CryptoAlgorithmIdentifier::RSA_PSS:
525     case CryptoAlgorithmIdentifier::RSA_OAEP:
526     case CryptoAlgorithmIdentifier::ECDSA:
527     case CryptoAlgorithmIdentifier::ECDH:
528     case CryptoAlgorithmIdentifier::AES_CTR:
529     case CryptoAlgorithmIdentifier::AES_CBC:
530     case CryptoAlgorithmIdentifier::AES_CMAC:
531     case CryptoAlgorithmIdentifier::AES_GCM:
532     case CryptoAlgorithmIdentifier::AES_CFB:
533     case CryptoAlgorithmIdentifier::HMAC:
534     case CryptoAlgorithmIdentifier::DH:
535     case CryptoAlgorithmIdentifier::SHA_1:
536     case CryptoAlgorithmIdentifier::SHA_224:
537     case CryptoAlgorithmIdentifier::SHA_256:
538     case CryptoAlgorithmIdentifier::SHA_384:
539     case CryptoAlgorithmIdentifier::SHA_512:
540     case CryptoAlgorithmIdentifier::CONCAT:
541     case CryptoAlgorithmIdentifier::HKDF_CTR:
542     case CryptoAlgorithmIdentifier::PBKDF2:
543         setDOMException(exec, NOT_SUPPORTED_ERR);
544         return nullptr;
545     }
546 }
547
548 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForUnwrapKey(JSC::ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSC::JSValue)
549 {
550     switch (algorithm) {
551     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
552     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
553     case CryptoAlgorithmIdentifier::RSA_PSS:
554     case CryptoAlgorithmIdentifier::RSA_OAEP:
555     case CryptoAlgorithmIdentifier::ECDSA:
556     case CryptoAlgorithmIdentifier::ECDH:
557     case CryptoAlgorithmIdentifier::AES_CTR:
558     case CryptoAlgorithmIdentifier::AES_CBC:
559     case CryptoAlgorithmIdentifier::AES_CMAC:
560     case CryptoAlgorithmIdentifier::AES_GCM:
561     case CryptoAlgorithmIdentifier::AES_CFB:
562     case CryptoAlgorithmIdentifier::HMAC:
563     case CryptoAlgorithmIdentifier::DH:
564     case CryptoAlgorithmIdentifier::SHA_1:
565     case CryptoAlgorithmIdentifier::SHA_224:
566     case CryptoAlgorithmIdentifier::SHA_256:
567     case CryptoAlgorithmIdentifier::SHA_384:
568     case CryptoAlgorithmIdentifier::SHA_512:
569     case CryptoAlgorithmIdentifier::CONCAT:
570     case CryptoAlgorithmIdentifier::HKDF_CTR:
571     case CryptoAlgorithmIdentifier::PBKDF2:
572         setDOMException(exec, NOT_SUPPORTED_ERR);
573         return nullptr;
574     }
575 }
576
577 }
578
579 #endif // ENABLE(SUBTLE_CRYPTO)