[GCrypt] ECDSA signing and verification support
[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, failure
226     // if the returned error is GPG_ERR_BAD_SIGNATURE, or an OperationError otherwise.
227     error = gcry_pk_verify(signatureSexp, dataSexp, keySexp);
228     if (error != GPG_ERR_NO_ERROR && gcry_err_code(error) != GPG_ERR_BAD_SIGNATURE) {
229         PAL::GCrypt::logError(error);
230         return std::nullopt;
231     }
232
233     return error == GPG_ERR_NO_ERROR;
234 }
235
236 void CryptoAlgorithmECDSA::platformSign(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& data, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
237 {
238     context.ref();
239     workQueue.dispatch(
240         [parameters = WTFMove(parameters), key = WTFMove(key), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {
241             auto& ecKey = downcast<CryptoKeyEC>(key.get());
242             auto& ecParameters = downcast<CryptoAlgorithmEcdsaParams>(*parameters);
243
244             auto output = gcryptSign(ecKey.platformKey(), data, ecParameters.hashIdentifier, ecKey.keySizeInBits() / 8);
245             if (!output) {
246                 // We should only dereference callbacks after being back to the Document/Worker threads.
247                 context.postTask(
248                     [callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
249                         exceptionCallback(OperationError);
250                         context.deref();
251                     });
252                 return;
253             }
254
255             // We should only dereference callbacks after being back to the Document/Worker threads.
256             context.postTask(
257                 [output = WTFMove(*output), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
258                     callback(output);
259                     context.deref();
260                 });
261         });
262 }
263
264 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)
265 {
266     context.ref();
267     workQueue.dispatch(
268         [parameters = WTFMove(parameters), key = WTFMove(key), signature = WTFMove(signature), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {
269             auto& ecKey = downcast<CryptoKeyEC>(key.get());
270             auto& ecParameters = downcast<CryptoAlgorithmEcdsaParams>(*parameters);
271
272             auto output = gcryptVerify(ecKey.platformKey(), signature, data, ecParameters.hashIdentifier, ecKey.keySizeInBits() / 8);
273             if (!output) {
274                 // We should only dereference callbacks after being back to the Document/Worker threads.
275                 context.postTask(
276                     [callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
277                         exceptionCallback(OperationError);
278                         context.deref();
279                     });
280                 return;
281             }
282
283             // We should only dereference callbacks after being back to the Document/Worker threads.
284             context.postTask(
285                 [output = WTFMove(*output), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {
286                     callback(output);
287                     context.deref();
288                 });
289         });
290 }
291
292 } // namespace WebCore
293
294 #endif // ENABLE(SUBTLE_CRYPTO)