[WTF] Import std::optional reference implementation as WTF::Optional
[WebKit-https.git] / Source / WebCore / crypto / algorithms / CryptoAlgorithmRSAES_PKCS1_v1_5.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 "CryptoAlgorithmRSAES_PKCS1_v1_5.h"
28
29 #if ENABLE(SUBTLE_CRYPTO)
30
31 #include "CryptoAlgorithmRsaKeyGenParams.h"
32 #include "CryptoAlgorithmRsaKeyGenParamsDeprecated.h"
33 #include "CryptoAlgorithmRsaKeyParamsWithHashDeprecated.h"
34 #include "CryptoKeyDataRSAComponents.h"
35 #include "CryptoKeyPair.h"
36 #include "CryptoKeyRSA.h"
37 #include "ExceptionCode.h"
38
39 namespace WebCore {
40
41 static const char* const ALG = "RSA1_5";
42
43 Ref<CryptoAlgorithm> CryptoAlgorithmRSAES_PKCS1_v1_5::create()
44 {
45     return adoptRef(*new CryptoAlgorithmRSAES_PKCS1_v1_5);
46 }
47
48 CryptoAlgorithmIdentifier CryptoAlgorithmRSAES_PKCS1_v1_5::identifier() const
49 {
50     return s_identifier;
51 }
52
53 bool CryptoAlgorithmRSAES_PKCS1_v1_5::keyAlgorithmMatches(const CryptoKey& key) const
54 {
55     if (key.algorithmIdentifier() != s_identifier)
56         return false;
57     ASSERT(is<CryptoKeyRSA>(key));
58
59     return true;
60 }
61
62 void CryptoAlgorithmRSAES_PKCS1_v1_5::encrypt(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&& key, Vector<uint8_t>&& plainText, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
63 {
64     if (key->type() != CryptoKeyType::Public) {
65         exceptionCallback(INVALID_ACCESS_ERR);
66         return;
67     }
68     platformEncrypt(WTFMove(key), WTFMove(plainText), WTFMove(callback), WTFMove(exceptionCallback), context, workQueue);
69 }
70
71 void CryptoAlgorithmRSAES_PKCS1_v1_5::decrypt(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&& key, Vector<uint8_t>&& cipherText, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
72 {
73     if (key->type() != CryptoKeyType::Private) {
74         exceptionCallback(INVALID_ACCESS_ERR);
75         return;
76     }
77     platformDecrypt(WTFMove(key), WTFMove(cipherText), WTFMove(callback), WTFMove(exceptionCallback), context, workQueue);
78 }
79
80 void CryptoAlgorithmRSAES_PKCS1_v1_5::generateKey(const std::unique_ptr<CryptoAlgorithmParameters>&& parameters, bool extractable, CryptoKeyUsageBitmap usages, KeyOrKeyPairCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context)
81 {
82     ASSERT(parameters);
83     const auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyGenParams>(*parameters);
84
85     if (usages & (CryptoKeyUsageSign | CryptoKeyUsageVerify | CryptoKeyUsageDeriveKey | CryptoKeyUsageDeriveBits | CryptoKeyUsageWrapKey | CryptoKeyUsageUnwrapKey)) {
86         exceptionCallback(SYNTAX_ERR);
87         return;
88     }
89
90     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
91         pair.publicKey()->setUsagesBitmap(pair.publicKey()->usagesBitmap() & CryptoKeyUsageEncrypt);
92         pair.privateKey()->setUsagesBitmap(pair.privateKey()->usagesBitmap() & CryptoKeyUsageDecrypt);
93         capturedCallback(nullptr, &pair);
94     };
95     auto failureCallback = [capturedCallback = WTFMove(exceptionCallback)]() {
96         capturedCallback(OperationError);
97     };
98     // Notice: CryptoAlgorithmIdentifier::SHA_1 is just a placeholder. It should not have any effect.
99     CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5, CryptoAlgorithmIdentifier::SHA_1, false, rsaParameters.modulusLength, rsaParameters.publicExponentVector(), extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);
100 }
101
102 void CryptoAlgorithmRSAES_PKCS1_v1_5::importKey(SubtleCrypto::KeyFormat format, KeyData&& data, const std::unique_ptr<CryptoAlgorithmParameters>&& parameters, bool extractable, CryptoKeyUsageBitmap usages, KeyCallback&& callback, ExceptionCallback&& exceptionCallback)
103 {
104     ASSERT(parameters);
105     RefPtr<CryptoKeyRSA> result;
106     switch (format) {
107     case SubtleCrypto::KeyFormat::Jwk: {
108         JsonWebKey key = WTFMove(WTF::get<JsonWebKey>(data));
109         if ((key.d && (usages ^ CryptoKeyUsageDecrypt)) || (!key.d && (usages ^ CryptoKeyUsageEncrypt))) {
110             exceptionCallback(SYNTAX_ERR);
111             return;
112         }
113         if (usages && key.use && key.use.value() != "enc") {
114             exceptionCallback(DataError);
115             return;
116         }
117         if (key.alg && key.alg.value() != ALG) {
118             exceptionCallback(DataError);
119             return;
120         }
121         result = CryptoKeyRSA::importJwk(parameters->identifier, std::nullopt, WTFMove(key), extractable, usages);
122         break;
123     }
124     default:
125         exceptionCallback(NOT_SUPPORTED_ERR);
126         return;
127     }
128     if (!result) {
129         exceptionCallback(DataError);
130         return;
131     }
132
133     callback(*result);
134 }
135
136 void CryptoAlgorithmRSAES_PKCS1_v1_5::exportKey(SubtleCrypto::KeyFormat format, Ref<CryptoKey>&& key, KeyDataCallback&& callback, ExceptionCallback&& exceptionCallback)
137 {
138     const auto& rsaKey = downcast<CryptoKeyRSA>(key.get());
139
140     if (!rsaKey.keySizeInBits()) {
141         exceptionCallback(OperationError);
142         return;
143     }
144
145     KeyData result;
146     switch (format) {
147     case SubtleCrypto::KeyFormat::Jwk: {
148         JsonWebKey jwk = rsaKey.exportJwk();
149         jwk.alg = String(ALG);
150         result = WTFMove(jwk);
151         break;
152     }
153     default:
154         exceptionCallback(NOT_SUPPORTED_ERR);
155         return;
156     }
157
158     callback(format, WTFMove(result));
159 }
160
161 ExceptionOr<void> CryptoAlgorithmRSAES_PKCS1_v1_5::encrypt(const CryptoAlgorithmParametersDeprecated&, const CryptoKey& key, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback)
162 {
163     if (!keyAlgorithmMatches(key))
164         return Exception { NOT_SUPPORTED_ERR };
165     return platformEncrypt(downcast<CryptoKeyRSA>(key), data, WTFMove(callback), WTFMove(failureCallback));
166 }
167
168 ExceptionOr<void> CryptoAlgorithmRSAES_PKCS1_v1_5::decrypt(const CryptoAlgorithmParametersDeprecated&, const CryptoKey& key, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback)
169 {
170     if (!keyAlgorithmMatches(key))
171         return Exception { NOT_SUPPORTED_ERR };
172     return platformDecrypt(downcast<CryptoKeyRSA>(key), data, WTFMove(callback), WTFMove(failureCallback));
173 }
174
175 ExceptionOr<void> CryptoAlgorithmRSAES_PKCS1_v1_5::generateKey(const CryptoAlgorithmParametersDeprecated& parameters, bool extractable, CryptoKeyUsageBitmap usages, KeyOrKeyPairCallback&& callback, VoidCallback&& failureCallback, ScriptExecutionContext& context)
176 {
177     auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyGenParamsDeprecated>(parameters);
178     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
179         capturedCallback(nullptr, &pair);
180     };
181     CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5, rsaParameters.hash, rsaParameters.hasHash, rsaParameters.modulusLength, rsaParameters.publicExponent, extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);
182     return { };
183 }
184
185 ExceptionOr<void> CryptoAlgorithmRSAES_PKCS1_v1_5::importKey(const CryptoAlgorithmParametersDeprecated& parameters, const CryptoKeyData& keyData, bool extractable, CryptoKeyUsageBitmap usage, KeyCallback&& callback, VoidCallback&& failureCallback)
186 {
187     auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyParamsWithHashDeprecated>(parameters);
188     auto& rsaComponents = downcast<CryptoKeyDataRSAComponents>(keyData);
189     auto result = CryptoKeyRSA::create(CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5, rsaParameters.hash, rsaParameters.hasHash, rsaComponents, extractable, usage);
190     if (!result) {
191         failureCallback();
192         return { };
193     }
194     callback(*result);
195     return { };
196 }
197
198 }
199
200 #endif // ENABLE(SUBTLE_CRYPTO)