Check WebCrypto parameter types when casting
[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 "CryptoAlgorithmRsaKeyGenParams.h"
37 #include "CryptoAlgorithmRsaSsaKeyParams.h"
38 #include "CryptoAlgorithmRsaSsaParams.h"
39 #include "ExceptionCode.h"
40 #include "JSCryptoOperationData.h"
41 #include "JSDOMBinding.h"
42 #include "JSDictionary.h"
43
44 using namespace JSC;
45
46 namespace WebCore {
47
48 bool JSCryptoAlgorithmDictionary::getAlgorithmIdentifier(ExecState* exec, JSValue value, CryptoAlgorithmIdentifier& algorithmIdentifier)
49 {
50     // typedef (Algorithm or DOMString) AlgorithmIdentifier;
51
52     String algorithmName;
53
54     if (value.isString())
55         algorithmName = value.toString(exec)->value(exec);
56     else if (value.isObject()) {
57         if (value.getObject()->inherits(StringObject::info()))
58             algorithmName = asString(asStringObject(value)->internalValue())->value(exec);
59         else {
60             // FIXME: This doesn't perform some checks mandated by WebIDL for dictionaries:
61             // - null and undefined input should be treated as if all elements in the dictionary were undefined;
62             // - undefined elements should be treated as having a default value, or as not present if there isn't such;
63             // - RegExp and Date objects cannot be converted to dictionaries.
64             //
65             // This is partially because we don't implement it elsewhere in WebCore yet, and partially because
66             // WebCrypto doesn't yet clearly specify what to do with non-present values in most cases anyway.
67
68             JSDictionary dictionary(exec, value.getObject());
69             dictionary.get("name", algorithmName);
70         }
71     }
72
73     if (exec->hadException())
74         return false;
75
76     if (!algorithmName.containsOnlyASCII()) {
77         throwSyntaxError(exec);
78         return false;
79     }
80
81     if (!CryptoAlgorithmRegistry::shared().getIdentifierForName(algorithmName, algorithmIdentifier)) {
82         setDOMException(exec, NOT_SUPPORTED_ERR);
83         return false;
84     }
85
86     return true;
87 }
88
89 static JSValue getProperty(ExecState* exec, JSObject* object, const char* name)
90 {
91     Identifier identifier(exec, name);
92     PropertySlot slot(object);
93
94     if (object->getPropertySlot(exec, identifier, slot))
95         return slot.getValue(exec, identifier);
96
97     return jsUndefined();
98 }
99
100 static bool getHashAlgorithm(JSDictionary& dictionary, CryptoAlgorithmIdentifier& result)
101 {
102     // FXIME: Teach JSDictionary how to return JSValues, and use that to get hash element value.
103
104     ExecState* exec = dictionary.execState();
105     JSObject* object = dictionary.initializerObject();
106
107     Identifier identifier(exec, "hash");
108     PropertySlot slot(object);
109
110     JSValue hash = getProperty(exec, object, "hash");
111     if (exec->hadException())
112         return false;
113
114     if (hash.isUndefinedOrNull()) {
115         setDOMException(exec, NOT_SUPPORTED_ERR);
116         return false;
117     }
118
119     return JSCryptoAlgorithmDictionary::getAlgorithmIdentifier(exec, hash, result);
120 }
121
122 static std::unique_ptr<CryptoAlgorithmParameters> createAesCbcParams(ExecState* exec, JSValue value)
123 {
124     if (!value.isObject()) {
125         throwTypeError(exec);
126         return nullptr;
127     }
128
129     JSValue iv = getProperty(exec, value.getObject(), "iv");
130     if (exec->hadException())
131         return nullptr;
132
133     auto result = std::make_unique<CryptoAlgorithmAesCbcParams>();
134
135     CryptoOperationData ivData;
136     if (!cryptoOperationDataFromJSValue(exec, iv, ivData)) {
137         ASSERT(exec->hadException());
138         return nullptr;
139     }
140
141     if (ivData.second != 16) {
142         exec->vm().throwException(exec, createError(exec, "AES-CBC initialization data must be 16 bytes"));
143         return nullptr;
144     }
145
146     memcpy(result->iv.data(), ivData.first, ivData.second);
147
148     return std::move(result);
149 }
150
151 static std::unique_ptr<CryptoAlgorithmParameters> createAesKeyGenParams(ExecState* exec, JSValue value)
152 {
153     if (!value.isObject()) {
154         throwTypeError(exec);
155         return nullptr;
156     }
157
158     auto result = std::make_unique<CryptoAlgorithmAesKeyGenParams>();
159
160     JSValue lengthValue = getProperty(exec, value.getObject(), "length");
161     if (exec->hadException())
162         return nullptr;
163
164     result->length = toUInt16(exec, lengthValue, EnforceRange);
165
166     return std::move(result);
167 }
168
169 static std::unique_ptr<CryptoAlgorithmParameters> createHmacParams(ExecState* exec, JSValue value)
170 {
171     if (!value.isObject()) {
172         throwTypeError(exec);
173         return nullptr;
174     }
175
176     JSDictionary jsDictionary(exec, value.getObject());
177     auto result = std::make_unique<CryptoAlgorithmHmacParams>();
178
179     if (!getHashAlgorithm(jsDictionary, result->hash)) {
180         ASSERT(exec->hadException());
181         return nullptr;
182     }
183
184     return std::move(result);
185 }
186
187 static std::unique_ptr<CryptoAlgorithmParameters> createHmacKeyParams(ExecState* exec, JSValue value)
188 {
189     if (!value.isObject()) {
190         throwTypeError(exec);
191         return nullptr;
192     }
193
194     JSDictionary jsDictionary(exec, value.getObject());
195     auto result = std::make_unique<CryptoAlgorithmHmacKeyParams>();
196
197     if (!getHashAlgorithm(jsDictionary, result->hash)) {
198         ASSERT(exec->hadException());
199         return nullptr;
200     }
201
202     result->hasLength = jsDictionary.get("length", result->length);
203     if (exec->hadException())
204         return nullptr;
205
206     return std::move(result);
207 }
208
209 static std::unique_ptr<CryptoAlgorithmParameters> createRsaKeyGenParams(ExecState* exec, JSValue value)
210 {
211     if (!value.isObject()) {
212         throwTypeError(exec);
213         return nullptr;
214     }
215
216     auto result = std::make_unique<CryptoAlgorithmRsaKeyGenParams>();
217
218     JSValue modulusLengthValue = getProperty(exec, value.getObject(), "modulusLength");
219     if (exec->hadException())
220         return nullptr;
221
222     // FIXME: Why no EnforceRange? Filed as <https://www.w3.org/Bugs/Public/show_bug.cgi?id=23779>.
223     result->modulusLength = toUInt32(exec, modulusLengthValue, NormalConversion);
224     if (exec->hadException())
225         return nullptr;
226
227     JSValue publicExponentValue = getProperty(exec, value.getObject(), "publicExponent");
228     if (exec->hadException())
229         return nullptr;
230
231     RefPtr<Uint8Array> publicExponentArray = toUint8Array(publicExponentValue);
232     if (!publicExponentArray) {
233         throwTypeError(exec, "Expected a Uint8Array in publicExponent");
234         return nullptr;
235     }
236     result->publicExponent.append(publicExponentArray->data(), publicExponentArray->byteLength());
237
238     return std::move(result);
239 }
240
241 static std::unique_ptr<CryptoAlgorithmParameters> createRsaSsaKeyParams(ExecState*, JSValue)
242 {
243     // WebCrypto RSASSA-PKCS1-v1_5 algorithm currently does not take any parameters to importKey.
244     return std::make_unique<CryptoAlgorithmRsaSsaKeyParams>();
245 }
246
247 static std::unique_ptr<CryptoAlgorithmParameters> createRsaSsaParams(ExecState* exec, JSValue value)
248 {
249     if (!value.isObject()) {
250         throwTypeError(exec);
251         return nullptr;
252     }
253
254     JSDictionary jsDictionary(exec, value.getObject());
255     auto result = std::make_unique<CryptoAlgorithmRsaSsaParams>();
256
257     if (!getHashAlgorithm(jsDictionary, result->hash)) {
258         ASSERT(exec->hadException());
259         return nullptr;
260     }
261
262     return std::move(result);
263 }
264
265 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForEncrypt(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
266 {
267     switch (algorithm) {
268     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
269     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
270     case CryptoAlgorithmIdentifier::RSA_PSS:
271     case CryptoAlgorithmIdentifier::RSA_OAEP:
272     case CryptoAlgorithmIdentifier::ECDSA:
273     case CryptoAlgorithmIdentifier::ECDH:
274     case CryptoAlgorithmIdentifier::AES_CTR:
275         setDOMException(exec, NOT_SUPPORTED_ERR);
276         return nullptr;
277     case CryptoAlgorithmIdentifier::AES_CBC:
278         return createAesCbcParams(exec, value);
279     case CryptoAlgorithmIdentifier::AES_CMAC:
280     case CryptoAlgorithmIdentifier::AES_GCM:
281     case CryptoAlgorithmIdentifier::AES_CFB:
282     case CryptoAlgorithmIdentifier::HMAC:
283     case CryptoAlgorithmIdentifier::DH:
284     case CryptoAlgorithmIdentifier::SHA_1:
285     case CryptoAlgorithmIdentifier::SHA_224:
286     case CryptoAlgorithmIdentifier::SHA_256:
287     case CryptoAlgorithmIdentifier::SHA_384:
288     case CryptoAlgorithmIdentifier::SHA_512:
289     case CryptoAlgorithmIdentifier::CONCAT:
290     case CryptoAlgorithmIdentifier::HKDF_CTR:
291     case CryptoAlgorithmIdentifier::PBKDF2:
292         setDOMException(exec, NOT_SUPPORTED_ERR);
293         return nullptr;
294     }
295 }
296
297 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDecrypt(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
298 {
299     switch (algorithm) {
300     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
301     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
302     case CryptoAlgorithmIdentifier::RSA_PSS:
303     case CryptoAlgorithmIdentifier::RSA_OAEP:
304     case CryptoAlgorithmIdentifier::ECDSA:
305     case CryptoAlgorithmIdentifier::ECDH:
306     case CryptoAlgorithmIdentifier::AES_CTR:
307         setDOMException(exec, NOT_SUPPORTED_ERR);
308         return nullptr;
309     case CryptoAlgorithmIdentifier::AES_CBC:
310         return createAesCbcParams(exec, value);
311     case CryptoAlgorithmIdentifier::AES_CMAC:
312     case CryptoAlgorithmIdentifier::AES_GCM:
313     case CryptoAlgorithmIdentifier::AES_CFB:
314     case CryptoAlgorithmIdentifier::HMAC:
315     case CryptoAlgorithmIdentifier::DH:
316     case CryptoAlgorithmIdentifier::SHA_1:
317     case CryptoAlgorithmIdentifier::SHA_224:
318     case CryptoAlgorithmIdentifier::SHA_256:
319     case CryptoAlgorithmIdentifier::SHA_384:
320     case CryptoAlgorithmIdentifier::SHA_512:
321     case CryptoAlgorithmIdentifier::CONCAT:
322     case CryptoAlgorithmIdentifier::HKDF_CTR:
323     case CryptoAlgorithmIdentifier::PBKDF2:
324         setDOMException(exec, NOT_SUPPORTED_ERR);
325         return nullptr;
326     }
327 }
328
329 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForSign(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
330 {
331     switch (algorithm) {
332     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
333         setDOMException(exec, NOT_SUPPORTED_ERR);
334         return nullptr;
335     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
336         return createRsaSsaParams(exec, value);
337     case CryptoAlgorithmIdentifier::RSA_PSS:
338     case CryptoAlgorithmIdentifier::RSA_OAEP:
339     case CryptoAlgorithmIdentifier::ECDSA:
340     case CryptoAlgorithmIdentifier::ECDH:
341     case CryptoAlgorithmIdentifier::AES_CTR:
342     case CryptoAlgorithmIdentifier::AES_CBC:
343     case CryptoAlgorithmIdentifier::AES_CMAC:
344     case CryptoAlgorithmIdentifier::AES_GCM:
345     case CryptoAlgorithmIdentifier::AES_CFB:
346         setDOMException(exec, NOT_SUPPORTED_ERR);
347         return nullptr;
348     case CryptoAlgorithmIdentifier::HMAC:
349         return createHmacParams(exec, value);
350     case CryptoAlgorithmIdentifier::DH:
351     case CryptoAlgorithmIdentifier::SHA_1:
352     case CryptoAlgorithmIdentifier::SHA_224:
353     case CryptoAlgorithmIdentifier::SHA_256:
354     case CryptoAlgorithmIdentifier::SHA_384:
355     case CryptoAlgorithmIdentifier::SHA_512:
356     case CryptoAlgorithmIdentifier::CONCAT:
357     case CryptoAlgorithmIdentifier::HKDF_CTR:
358     case CryptoAlgorithmIdentifier::PBKDF2:
359         setDOMException(exec, NOT_SUPPORTED_ERR);
360         return nullptr;
361     }
362 }
363
364 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForVerify(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
365 {
366     switch (algorithm) {
367     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
368         setDOMException(exec, NOT_SUPPORTED_ERR);
369         return nullptr;
370     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
371         return createRsaSsaParams(exec, value);
372     case CryptoAlgorithmIdentifier::RSA_PSS:
373     case CryptoAlgorithmIdentifier::RSA_OAEP:
374     case CryptoAlgorithmIdentifier::ECDSA:
375     case CryptoAlgorithmIdentifier::ECDH:
376     case CryptoAlgorithmIdentifier::AES_CTR:
377     case CryptoAlgorithmIdentifier::AES_CBC:
378     case CryptoAlgorithmIdentifier::AES_CMAC:
379     case CryptoAlgorithmIdentifier::AES_GCM:
380     case CryptoAlgorithmIdentifier::AES_CFB:
381         setDOMException(exec, NOT_SUPPORTED_ERR);
382         return nullptr;
383     case CryptoAlgorithmIdentifier::HMAC:
384         return createHmacParams(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::createParametersForDigest(ExecState* exec, CryptoAlgorithmIdentifier algorithm, 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         setDOMException(exec, NOT_SUPPORTED_ERR);
416         return nullptr;
417     case CryptoAlgorithmIdentifier::SHA_1:
418     case CryptoAlgorithmIdentifier::SHA_224:
419     case CryptoAlgorithmIdentifier::SHA_256:
420     case CryptoAlgorithmIdentifier::SHA_384:
421     case CryptoAlgorithmIdentifier::SHA_512:
422         return std::make_unique<CryptoAlgorithmParameters>();
423     case CryptoAlgorithmIdentifier::CONCAT:
424     case CryptoAlgorithmIdentifier::HKDF_CTR:
425     case CryptoAlgorithmIdentifier::PBKDF2:
426         setDOMException(exec, NOT_SUPPORTED_ERR);
427         return nullptr;
428     }
429 }
430
431 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForGenerateKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
432 {
433     switch (algorithm) {
434     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
435     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
436     case CryptoAlgorithmIdentifier::RSA_PSS:
437     case CryptoAlgorithmIdentifier::RSA_OAEP:
438         return createRsaKeyGenParams(exec, value);
439     case CryptoAlgorithmIdentifier::ECDSA:
440     case CryptoAlgorithmIdentifier::ECDH:
441         setDOMException(exec, NOT_SUPPORTED_ERR);
442         return nullptr;
443     case CryptoAlgorithmIdentifier::AES_CTR:
444     case CryptoAlgorithmIdentifier::AES_CBC:
445     case CryptoAlgorithmIdentifier::AES_CMAC:
446     case CryptoAlgorithmIdentifier::AES_GCM:
447     case CryptoAlgorithmIdentifier::AES_CFB:
448         return createAesKeyGenParams(exec, value);
449     case CryptoAlgorithmIdentifier::HMAC:
450         return createHmacKeyParams(exec, value);
451     case CryptoAlgorithmIdentifier::DH:
452     case CryptoAlgorithmIdentifier::SHA_1:
453     case CryptoAlgorithmIdentifier::SHA_224:
454     case CryptoAlgorithmIdentifier::SHA_256:
455     case CryptoAlgorithmIdentifier::SHA_384:
456     case CryptoAlgorithmIdentifier::SHA_512:
457     case CryptoAlgorithmIdentifier::CONCAT:
458     case CryptoAlgorithmIdentifier::HKDF_CTR:
459     case CryptoAlgorithmIdentifier::PBKDF2:
460         setDOMException(exec, NOT_SUPPORTED_ERR);
461         return nullptr;
462     }
463 }
464
465 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDeriveKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue)
466 {
467     switch (algorithm) {
468     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
469     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
470     case CryptoAlgorithmIdentifier::RSA_PSS:
471     case CryptoAlgorithmIdentifier::RSA_OAEP:
472     case CryptoAlgorithmIdentifier::ECDSA:
473     case CryptoAlgorithmIdentifier::ECDH:
474     case CryptoAlgorithmIdentifier::AES_CTR:
475     case CryptoAlgorithmIdentifier::AES_CBC:
476     case CryptoAlgorithmIdentifier::AES_CMAC:
477     case CryptoAlgorithmIdentifier::AES_GCM:
478     case CryptoAlgorithmIdentifier::AES_CFB:
479     case CryptoAlgorithmIdentifier::HMAC:
480     case CryptoAlgorithmIdentifier::DH:
481     case CryptoAlgorithmIdentifier::SHA_1:
482     case CryptoAlgorithmIdentifier::SHA_224:
483     case CryptoAlgorithmIdentifier::SHA_256:
484     case CryptoAlgorithmIdentifier::SHA_384:
485     case CryptoAlgorithmIdentifier::SHA_512:
486     case CryptoAlgorithmIdentifier::CONCAT:
487     case CryptoAlgorithmIdentifier::HKDF_CTR:
488     case CryptoAlgorithmIdentifier::PBKDF2:
489         setDOMException(exec, NOT_SUPPORTED_ERR);
490         return nullptr;
491     }
492 }
493
494 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForDeriveBits(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue)
495 {
496     switch (algorithm) {
497     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
498     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
499     case CryptoAlgorithmIdentifier::RSA_PSS:
500     case CryptoAlgorithmIdentifier::RSA_OAEP:
501     case CryptoAlgorithmIdentifier::ECDSA:
502     case CryptoAlgorithmIdentifier::ECDH:
503     case CryptoAlgorithmIdentifier::AES_CTR:
504     case CryptoAlgorithmIdentifier::AES_CBC:
505     case CryptoAlgorithmIdentifier::AES_CMAC:
506     case CryptoAlgorithmIdentifier::AES_GCM:
507     case CryptoAlgorithmIdentifier::AES_CFB:
508     case CryptoAlgorithmIdentifier::HMAC:
509     case CryptoAlgorithmIdentifier::DH:
510     case CryptoAlgorithmIdentifier::SHA_1:
511     case CryptoAlgorithmIdentifier::SHA_224:
512     case CryptoAlgorithmIdentifier::SHA_256:
513     case CryptoAlgorithmIdentifier::SHA_384:
514     case CryptoAlgorithmIdentifier::SHA_512:
515     case CryptoAlgorithmIdentifier::CONCAT:
516     case CryptoAlgorithmIdentifier::HKDF_CTR:
517     case CryptoAlgorithmIdentifier::PBKDF2:
518         setDOMException(exec, NOT_SUPPORTED_ERR);
519         return nullptr;
520     }
521 }
522
523 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForImportKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue value)
524 {
525     switch (algorithm) {
526     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
527         return std::make_unique<CryptoAlgorithmParameters>();
528     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
529         return createRsaSsaKeyParams(exec, value);
530     case CryptoAlgorithmIdentifier::RSA_PSS:
531     case CryptoAlgorithmIdentifier::RSA_OAEP:
532     case CryptoAlgorithmIdentifier::ECDSA:
533     case CryptoAlgorithmIdentifier::ECDH:
534     case CryptoAlgorithmIdentifier::AES_CTR:
535     case CryptoAlgorithmIdentifier::AES_CBC:
536     case CryptoAlgorithmIdentifier::AES_CMAC:
537     case CryptoAlgorithmIdentifier::AES_GCM:
538     case CryptoAlgorithmIdentifier::AES_CFB:
539         return std::make_unique<CryptoAlgorithmParameters>();
540     case CryptoAlgorithmIdentifier::HMAC:
541         return createHmacParams(exec, value);
542     case CryptoAlgorithmIdentifier::DH:
543         return std::make_unique<CryptoAlgorithmParameters>();
544     case CryptoAlgorithmIdentifier::SHA_1:
545     case CryptoAlgorithmIdentifier::SHA_224:
546     case CryptoAlgorithmIdentifier::SHA_256:
547     case CryptoAlgorithmIdentifier::SHA_384:
548     case CryptoAlgorithmIdentifier::SHA_512:
549     case CryptoAlgorithmIdentifier::CONCAT:
550     case CryptoAlgorithmIdentifier::HKDF_CTR:
551     case CryptoAlgorithmIdentifier::PBKDF2:
552         setDOMException(exec, NOT_SUPPORTED_ERR);
553         return nullptr;
554     }
555 }
556
557 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForExportKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue)
558 {
559     switch (algorithm) {
560     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
561     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
562     case CryptoAlgorithmIdentifier::RSA_PSS:
563     case CryptoAlgorithmIdentifier::RSA_OAEP:
564     case CryptoAlgorithmIdentifier::ECDSA:
565     case CryptoAlgorithmIdentifier::ECDH:
566     case CryptoAlgorithmIdentifier::AES_CTR:
567     case CryptoAlgorithmIdentifier::AES_CBC:
568     case CryptoAlgorithmIdentifier::AES_CMAC:
569     case CryptoAlgorithmIdentifier::AES_GCM:
570     case CryptoAlgorithmIdentifier::AES_CFB:
571     case CryptoAlgorithmIdentifier::HMAC:
572     case CryptoAlgorithmIdentifier::DH:
573         return std::make_unique<CryptoAlgorithmParameters>();
574     case CryptoAlgorithmIdentifier::SHA_1:
575     case CryptoAlgorithmIdentifier::SHA_224:
576     case CryptoAlgorithmIdentifier::SHA_256:
577     case CryptoAlgorithmIdentifier::SHA_384:
578     case CryptoAlgorithmIdentifier::SHA_512:
579     case CryptoAlgorithmIdentifier::CONCAT:
580     case CryptoAlgorithmIdentifier::HKDF_CTR:
581     case CryptoAlgorithmIdentifier::PBKDF2:
582         setDOMException(exec, NOT_SUPPORTED_ERR);
583         return nullptr;
584     }
585 }
586
587 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForWrapKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue)
588 {
589     switch (algorithm) {
590     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
591     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
592     case CryptoAlgorithmIdentifier::RSA_PSS:
593     case CryptoAlgorithmIdentifier::RSA_OAEP:
594     case CryptoAlgorithmIdentifier::ECDSA:
595     case CryptoAlgorithmIdentifier::ECDH:
596     case CryptoAlgorithmIdentifier::AES_CTR:
597     case CryptoAlgorithmIdentifier::AES_CBC:
598     case CryptoAlgorithmIdentifier::AES_CMAC:
599     case CryptoAlgorithmIdentifier::AES_GCM:
600     case CryptoAlgorithmIdentifier::AES_CFB:
601     case CryptoAlgorithmIdentifier::HMAC:
602     case CryptoAlgorithmIdentifier::DH:
603     case CryptoAlgorithmIdentifier::SHA_1:
604     case CryptoAlgorithmIdentifier::SHA_224:
605     case CryptoAlgorithmIdentifier::SHA_256:
606     case CryptoAlgorithmIdentifier::SHA_384:
607     case CryptoAlgorithmIdentifier::SHA_512:
608     case CryptoAlgorithmIdentifier::CONCAT:
609     case CryptoAlgorithmIdentifier::HKDF_CTR:
610     case CryptoAlgorithmIdentifier::PBKDF2:
611         setDOMException(exec, NOT_SUPPORTED_ERR);
612         return nullptr;
613     }
614 }
615
616 std::unique_ptr<CryptoAlgorithmParameters> JSCryptoAlgorithmDictionary::createParametersForUnwrapKey(ExecState* exec, CryptoAlgorithmIdentifier algorithm, JSValue)
617 {
618     switch (algorithm) {
619     case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
620     case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
621     case CryptoAlgorithmIdentifier::RSA_PSS:
622     case CryptoAlgorithmIdentifier::RSA_OAEP:
623     case CryptoAlgorithmIdentifier::ECDSA:
624     case CryptoAlgorithmIdentifier::ECDH:
625     case CryptoAlgorithmIdentifier::AES_CTR:
626     case CryptoAlgorithmIdentifier::AES_CBC:
627     case CryptoAlgorithmIdentifier::AES_CMAC:
628     case CryptoAlgorithmIdentifier::AES_GCM:
629     case CryptoAlgorithmIdentifier::AES_CFB:
630     case CryptoAlgorithmIdentifier::HMAC:
631     case CryptoAlgorithmIdentifier::DH:
632     case CryptoAlgorithmIdentifier::SHA_1:
633     case CryptoAlgorithmIdentifier::SHA_224:
634     case CryptoAlgorithmIdentifier::SHA_256:
635     case CryptoAlgorithmIdentifier::SHA_384:
636     case CryptoAlgorithmIdentifier::SHA_512:
637     case CryptoAlgorithmIdentifier::CONCAT:
638     case CryptoAlgorithmIdentifier::HKDF_CTR:
639     case CryptoAlgorithmIdentifier::PBKDF2:
640         setDOMException(exec, NOT_SUPPORTED_ERR);
641         return nullptr;
642     }
643 }
644
645 }
646
647 #endif // ENABLE(SUBTLE_CRYPTO)