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