[GCrypt] Fix PK verification for ECDSA
[WebKit-https.git] / Source / WebCore / crypto / gcrypt / CryptoAlgorithmECDSAGCrypt.cpp
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2017 Metrological Group B.V.
4  * Copyright (C) 2017 Igalia S.L.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25  * THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #include "config.h"
29 #include "CryptoAlgorithmECDSA.h"
30
31 #if ENABLE(SUBTLE_CRYPTO)
32
33 #include "CryptoAlgorithmEcdsaParams.h"
34 #include "CryptoKeyEC.h"
35 #include "ExceptionCode.h"
36 #include "ScriptExecutionContext.h"
37 #include <pal/crypto/CryptoDigest.h>
38 #include <pal/crypto/gcrypt/Handle.h>
39 #include <pal/crypto/gcrypt/Utilities.h>
40
41 namespace WebCore {
42
43 static std::optional<PAL::CryptoDigest::Algorithm> hashCryptoDigestAlgorithm(CryptoAlgorithmIdentifier identifier)
44 {
45     switch (identifier) {
46     case CryptoAlgorithmIdentifier::SHA_1:
47         return PAL::CryptoDigest::Algorithm::SHA_1;
48     case CryptoAlgorithmIdentifier::SHA_224:
49         return PAL::CryptoDigest::Algorithm::SHA_224;
50     case CryptoAlgorithmIdentifier::SHA_256:
51         return PAL::CryptoDigest::Algorithm::SHA_256;
52     case CryptoAlgorithmIdentifier::SHA_384:
53         return PAL::CryptoDigest::Algorithm::SHA_384;
54     case CryptoAlgorithmIdentifier::SHA_512:
55         return PAL::CryptoDigest::Algorithm::SHA_512;
56     default:
57         return std::nullopt;
58     }
59 }
60
61 static std::optional<const char*> hashAlgorithmName(CryptoAlgorithmIdentifier identifier)
62 {
63     switch (identifier) {
64     case CryptoAlgorithmIdentifier::SHA_1:
65         return "sha1";
66     case CryptoAlgorithmIdentifier::SHA_224:
67         return "sha224";
68     case CryptoAlgorithmIdentifier::SHA_256:
69         return "sha256";
70     case CryptoAlgorithmIdentifier::SHA_384:
71         return "sha384";
72     case CryptoAlgorithmIdentifier::SHA_512:
73         return "sha512";
74     default:
75         return std::nullopt;
76     }
77 }
78
79 std::optional<Vector<uint8_t>> mpiData(gcry_sexp_t paramSexp)
80 {
81     // Retrieve the MPI value stored in the s-expression: (name mpi-data)
82     PAL::GCrypt::Handle<gcry_mpi_t> paramMPI(gcry_sexp_nth_mpi(paramSexp, 1, GCRYMPI_FMT_USG));
83     if (!paramMPI)
84         return std::nullopt;
85
86     // Query the data length first to properly prepare the buffer.
87     size_t dataLength = 0;
88     gcry_error_t error = gcry_mpi_print(GCRYMPI_FMT_USG, nullptr, 0, &dataLength, paramMPI);
89     if (error != GPG_ERR_NO_ERROR) {
90         PAL::GCrypt::logError(error);
91         return std::nullopt;
92     }
93
94     // Finally, copy the MPI data into a properly-sized buffer.
95     Vector<uint8_t> output(dataLength);
96     error = gcry_mpi_print(GCRYMPI_FMT_USG, output.data(), output.size(), nullptr, paramMPI);
97     if (error != GPG_ERR_NO_ERROR) {
98         PAL::GCrypt::logError(error);
99         return std::nullopt;
100     }
101
102     return output;
103 }
104
105 static std::optional<Vector<uint8_t>> gcryptSign(gcry_sexp_t keySexp, const Vector<uint8_t>& data, CryptoAlgorithmIdentifier hashAlgorithmIdentifier, size_t keySizeInBytes)
106 {
107     // Perform digest operation with the specified algorithm on the given data.
108     Vector<uint8_t> dataHash;
109     {
110         auto digestAlgorithm = hashCryptoDigestAlgorithm(hashAlgorithmIdentifier);
111         if (!digestAlgorithm)
112             return std::nullopt;
113
114         auto digest = PAL::CryptoDigest::create(*digestAlgorithm);
115         if (!digest)
116             return std::nullopt;
117
118         digest->addBytes(data.data(), data.size());
119         dataHash = digest->computeHash();
120     }
121
122     // Construct the data s-expression that contains raw hashed data.
123     PAL::GCrypt::Handle<gcry_sexp_t> dataSexp;
124     {
125         auto shaAlgorithm = hashAlgorithmName(hashAlgorithmIdentifier);
126         if (!shaAlgorithm)
127             return std::nullopt;
128
129         gcry_error_t error = gcry_sexp_build(&dataSexp, nullptr, "(data(flags raw)(hash %s %b))",
130             *shaAlgorithm, dataHash.size(), dataHash.data());
131         if (error != GPG_ERR_NO_ERROR) {
132             PAL::GCrypt::logError(error);
133             return std::nullopt;
134         }
135     }
136
137     // Perform the PK signing, retrieving a sig-val s-expression of the following form:
138     // (sig-val
139     //   (dsa
140     //     (r r-mpi)
141     //     (s s-mpi)))
142     PAL::GCrypt::Handle<gcry_sexp_t> signatureSexp;
143     gcry_error_t error = gcry_pk_sign(&signatureSexp, dataSexp, keySexp);
144     if (error != GPG_ERR_NO_ERROR) {
145         PAL::GCrypt::logError(error);
146         return std::nullopt;
147     }
148
149     // Retrieve MPI data of the resulting r and s integers. They are concatenated into
150     // a single buffer after checking that the data length matches the key size.
151     // FIXME: But r and s integers can still be valid even if they're of shorter size.
152     // https://bugs.webkit.org/show_bug.cgi?id=171535
153     Vector<uint8_t> signature;
154     {
155         PAL::GCrypt::Handle<gcry_sexp_t> rSexp(gcry_sexp_find_token(signatureSexp, "r", 0));
156         if (!rSexp)
157             return std::nullopt;
158
159         auto rData = mpiData(rSexp);
160         if (!rData || rData->size() != keySizeInBytes)
161             return std::nullopt;
162
163         signature.appendVector(*rData);
164     }
165     {
166         PAL::GCrypt::Handle<gcry_sexp_t> sSexp(gcry_sexp_find_token(signatureSexp, "s", 0));
167         if (!sSexp)
168             return std::nullopt;
169
170         auto sData = mpiData(sSexp);
171         if (!sData || sData->size() != keySizeInBytes)
172             return std::nullopt;
173
174         signature.appendVector(*sData);
175     }
176
177     return signature;
178 }
179
180 static std::optional<bool> gcryptVerify(gcry_sexp_t keySexp, const Vector<uint8_t>& signature, const Vector<uint8_t>& data, CryptoAlgorithmIdentifier hashAlgorithmIdentifier, size_t keySizeInBytes)
181 {
182     // Bail if the signature size isn't double the key size (i.e. concatenated r and s components).
183     if (signature.size() != keySizeInBytes * 2)
184         return false;
185
186     // Perform digest operation with the specified algorithm on the given data.
187     Vector<uint8_t> dataHash;
188     {
189         auto digestAlgorithm = hashCryptoDigestAlgorithm(hashAlgorithmIdentifier);
190         if (!digestAlgorithm)
191             return std::nullopt;
192
193         auto digest = PAL::CryptoDigest::create(*digestAlgorithm);
194         if (!digest)
195             return std::nullopt;
196
197         digest->addBytes(data.data(), data.size());
198         dataHash = digest->computeHash();
199     }
200
201     // Construct the sig-val s-expression, extracting the r and s components from the signature vector.
202     PAL::GCrypt::Handle<gcry_sexp_t> signatureSexp;
203     gcry_error_t error = gcry_sexp_build(&signatureSexp, nullptr, "(sig-val(ecdsa(r %b)(s %b)))",
204         keySizeInBytes, signature.data(), keySizeInBytes, signature.data() + keySizeInBytes);
205     if (error != GPG_ERR_NO_ERROR) {
206         PAL::GCrypt::logError(error);
207         return std::nullopt;
208     }
209
210     // Construct the data s-expression that contains raw hashed data.
211     PAL::GCrypt::Handle<gcry_sexp_t> dataSexp;
212     {
213         auto shaAlgorithm = hashAlgorithmName(hashAlgorithmIdentifier);
214         if (!shaAlgorithm)
215             return std::nullopt;
216
217         error = gcry_sexp_build(&dataSexp, nullptr, "(data(flags raw)(hash %s %b))",
218             *shaAlgorithm, dataHash.size(), dataHash.data());
219         if (error != GPG_ERR_NO_ERROR) {
220             PAL::GCrypt::logError(error);
221             return std::nullopt;
222         }
223     }
224
225     // Perform the PK verification. We report success if there's no error returned, or
226     // a failure in any other case. OperationError should not be returned at this point,
227     // avoiding spilling information about the exact cause of verification failure.
228     error = gcry_pk_verify(signatureSexp, dataSexp, keySexp);
229     return { error == GPG_ERR_NO_ERROR };
230 }
231
232 void CryptoAlgorithmECDSA::platformSign(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& data, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
233 {
234     context.ref();
235     workQueue.dispatch(
236         [parameters = WTFMove(parameters), key = WTFMove(key), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {
237             auto& ecKey = downcast<CryptoKeyEC>(key.get());
238             auto& ecParameters = downcast<CryptoAlgorithmEcdsaParams>(*parameters);
239
240             auto output = gcryptSign(ecKey.platformKey(), data, ecParameters.hashIdentifier, ecKey.keySizeInBits() / 8);
241             if (!output) {
242                 // We should only dereference callbacks after being back to the Document/Worker threads.
243                 context.postTask(
244                     [callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
245                         exceptionCallback(OperationError);
246                         context.deref();
247                     });
248                 return;
249             }
250
251             // We should only dereference callbacks after being back to the Document/Worker threads.
252             context.postTask(
253                 [output = WTFMove(*output), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
254                     callback(output);
255                     context.deref();
256                 });
257         });
258 }
259
260 void CryptoAlgorithmECDSA::platformVerify(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& signature, Vector<uint8_t>&& data, BoolCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
261 {
262     context.ref();
263     workQueue.dispatch(
264         [parameters = WTFMove(parameters), key = WTFMove(key), signature = WTFMove(signature), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {
265             auto& ecKey = downcast<CryptoKeyEC>(key.get());
266             auto& ecParameters = downcast<CryptoAlgorithmEcdsaParams>(*parameters);
267
268             auto output = gcryptVerify(ecKey.platformKey(), signature, data, ecParameters.hashIdentifier, ecKey.keySizeInBits() / 8);
269             if (!output) {
270                 // We should only dereference callbacks after being back to the Document/Worker threads.
271                 context.postTask(
272                     [callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
273                         exceptionCallback(OperationError);
274                         context.deref();
275                     });
276                 return;
277             }
278
279             // We should only dereference callbacks after being back to the Document/Worker threads.
280             context.postTask(
281                 [output = WTFMove(*output), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
282                     callback(output);
283                     context.deref();
284                 });
285         });
286 }
287
288 } // namespace WebCore
289
290 #endif // ENABLE(SUBTLE_CRYPTO)