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