make update
[openssl.git] / providers / implementations / signature / sm2sig.c
1 /*
2  * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * ECDSA low level APIs are deprecated for public use, but still ok for
12  * internal use - SM2 implemetation uses ECDSA_size() function.
13  */
14 #include "internal/deprecated.h"
15
16 #include <string.h> /* memcpy */
17 #include <openssl/crypto.h>
18 #include <openssl/core_dispatch.h>
19 #include <openssl/core_names.h>
20 #include <openssl/dsa.h>
21 #include <openssl/params.h>
22 #include <openssl/evp.h>
23 #include <openssl/err.h>
24 #include "internal/nelem.h"
25 #include "internal/sizes.h"
26 #include "internal/cryptlib.h"
27 #include "prov/providercommonerr.h"
28 #include "prov/implementations.h"
29 #include "prov/provider_ctx.h"
30 #include "crypto/ec.h"
31 #include "crypto/sm2.h"
32 #include "prov/der_sm2.h"
33
34 static OSSL_FUNC_signature_newctx_fn sm2sig_newctx;
35 static OSSL_FUNC_signature_sign_init_fn sm2sig_signature_init;
36 static OSSL_FUNC_signature_verify_init_fn sm2sig_signature_init;
37 static OSSL_FUNC_signature_sign_fn sm2sig_sign;
38 static OSSL_FUNC_signature_verify_fn sm2sig_verify;
39 static OSSL_FUNC_signature_digest_sign_init_fn sm2sig_digest_signverify_init;
40 static OSSL_FUNC_signature_digest_sign_update_fn sm2sig_digest_signverify_update;
41 static OSSL_FUNC_signature_digest_sign_final_fn sm2sig_digest_sign_final;
42 static OSSL_FUNC_signature_digest_verify_init_fn sm2sig_digest_signverify_init;
43 static OSSL_FUNC_signature_digest_verify_update_fn sm2sig_digest_signverify_update;
44 static OSSL_FUNC_signature_digest_verify_final_fn sm2sig_digest_verify_final;
45 static OSSL_FUNC_signature_freectx_fn sm2sig_freectx;
46 static OSSL_FUNC_signature_dupctx_fn sm2sig_dupctx;
47 static OSSL_FUNC_signature_get_ctx_params_fn sm2sig_get_ctx_params;
48 static OSSL_FUNC_signature_gettable_ctx_params_fn sm2sig_gettable_ctx_params;
49 static OSSL_FUNC_signature_set_ctx_params_fn sm2sig_set_ctx_params;
50 static OSSL_FUNC_signature_settable_ctx_params_fn sm2sig_settable_ctx_params;
51 static OSSL_FUNC_signature_get_ctx_md_params_fn sm2sig_get_ctx_md_params;
52 static OSSL_FUNC_signature_gettable_ctx_md_params_fn sm2sig_gettable_ctx_md_params;
53 static OSSL_FUNC_signature_set_ctx_md_params_fn sm2sig_set_ctx_md_params;
54 static OSSL_FUNC_signature_settable_ctx_md_params_fn sm2sig_settable_ctx_md_params;
55
56 /*
57  * What's passed as an actual key is defined by the KEYMGMT interface.
58  * We happen to know that our KEYMGMT simply passes EC structures, so
59  * we use that here too.
60  */
61 typedef struct {
62     OSSL_LIB_CTX *libctx;
63     char *propq;
64     EC_KEY *ec;
65
66     /*
67      * Flag to determine if the hash function can be changed (1) or not (0)
68      * Because it's dangerous to change during a DigestSign or DigestVerify
69      * operation, this flag is cleared by their Init function, and set again
70      * by their Final function.
71      */
72     unsigned int flag_allow_md : 1;
73     /*
74      * Flag to termine if the 'z' digest needs to be computed and fed to the
75      * hash function.
76      * This flag should be set on initialization and the compuation should
77      * be performed only once, on first update.
78      */
79     unsigned int flag_compute_z_digest : 1;
80
81     char mdname[OSSL_MAX_NAME_SIZE];
82
83     /* The Algorithm Identifier of the combined signature algorithm */
84     unsigned char aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE];
85     unsigned char *aid;
86     size_t  aid_len;
87
88     /* main digest */
89     EVP_MD *md;
90     EVP_MD_CTX *mdctx;
91     size_t mdsize;
92
93     /* SM2 ID used for calculating the Z value */
94     unsigned char *id;
95     size_t id_len;
96 } PROV_SM2_CTX;
97
98 static void *sm2sig_newctx(void *provctx, const char *propq)
99 {
100     PROV_SM2_CTX *ctx = OPENSSL_zalloc(sizeof(PROV_SM2_CTX));
101
102     if (ctx == NULL)
103         return NULL;
104
105     ctx->libctx = PROV_LIBCTX_OF(provctx);
106     if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL) {
107         OPENSSL_free(ctx);
108         ctx = NULL;
109         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
110     }
111     /* don't allow to change MD, and in fact there is no such need */
112     ctx->flag_allow_md = 0;
113     return ctx;
114 }
115
116 static int sm2sig_signature_init(void *vpsm2ctx, void *ec)
117 {
118     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
119
120     if (psm2ctx == NULL || ec == NULL || !EC_KEY_up_ref(ec))
121         return 0;
122     EC_KEY_free(psm2ctx->ec);
123     psm2ctx->ec = ec;
124     return 1;
125 }
126
127 static int sm2sig_sign(void *vpsm2ctx, unsigned char *sig, size_t *siglen,
128                        size_t sigsize, const unsigned char *tbs, size_t tbslen)
129 {
130     PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
131     int ret;
132     unsigned int sltmp;
133     /* SM2 uses ECDSA_size as well */
134     size_t ecsize = ECDSA_size(ctx->ec);
135
136     if (sig == NULL) {
137         *siglen = ecsize;
138         return 1;
139     }
140
141     if (sigsize < (size_t)ecsize)
142         return 0;
143
144     if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
145         return 0;
146
147     ret = sm2_internal_sign(tbs, tbslen, sig, &sltmp, ctx->ec);
148     if (ret <= 0)
149         return 0;
150
151     *siglen = sltmp;
152     return 1;
153 }
154
155 static int sm2sig_verify(void *vpsm2ctx, const unsigned char *sig, size_t siglen,
156                          const unsigned char *tbs, size_t tbslen)
157 {
158     PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
159
160     if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
161         return 0;
162
163     return sm2_internal_verify(tbs, tbslen, sig, siglen, ctx->ec);
164 }
165
166 static void free_md(PROV_SM2_CTX *ctx)
167 {
168     EVP_MD_CTX_free(ctx->mdctx);
169     EVP_MD_free(ctx->md);
170     ctx->mdctx = NULL;
171     ctx->md = NULL;
172     ctx->mdsize = 0;
173 }
174
175 static int sm2sig_digest_signverify_init(void *vpsm2ctx, const char *mdname,
176                                          void *ec)
177 {
178     PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
179     int md_nid = NID_sm3;
180     WPACKET pkt;
181     int ret = 0;
182
183     free_md(ctx);
184
185     if (!sm2sig_signature_init(vpsm2ctx, ec))
186         return ret;
187
188     ctx->md = EVP_MD_fetch(ctx->libctx, mdname, ctx->propq);
189     ctx->mdsize = EVP_MD_size(ctx->md);
190     ctx->mdctx = EVP_MD_CTX_new();
191     if (ctx->mdctx == NULL)
192         goto error;
193
194     /*
195      * TODO(3.0) Should we care about DER writing errors?
196      * All it really means is that for some reason, there's no
197      * AlgorithmIdentifier to be had, but the operation itself is
198      * still valid, just as long as it's not used to construct
199      * anything that needs an AlgorithmIdentifier.
200      */
201     ctx->aid_len = 0;
202     if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf))
203         && DER_w_algorithmIdentifier_SM2_with_MD(&pkt, -1, ctx->ec, md_nid)
204         && WPACKET_finish(&pkt)) {
205         WPACKET_get_total_written(&pkt, &ctx->aid_len);
206         ctx->aid = WPACKET_get_curr(&pkt);
207     }
208     WPACKET_cleanup(&pkt);
209
210     if (!EVP_DigestInit_ex(ctx->mdctx, ctx->md, NULL))
211         goto error;
212
213     ctx->flag_compute_z_digest = 1;
214
215     ret = 1;
216
217  error:
218     if (!ret)
219         free_md(ctx);
220     return ret;
221 }
222
223 static int sm2sig_compute_z_digest(PROV_SM2_CTX *ctx)
224 {
225     uint8_t *z = NULL;
226     int ret = 1;
227
228     if (ctx->flag_compute_z_digest) {
229         /* Only do this once */
230         ctx->flag_compute_z_digest = 0;
231
232         if ((z = OPENSSL_zalloc(ctx->mdsize)) == NULL
233             /* get hashed prefix 'z' of tbs message */
234             || !sm2_compute_z_digest(z, ctx->md, ctx->id, ctx->id_len, ctx->ec)
235             || !EVP_DigestUpdate(ctx->mdctx, z, ctx->mdsize))
236             ret = 0;
237         OPENSSL_free(z);
238     }
239
240     return ret;
241 }
242
243 int sm2sig_digest_signverify_update(void *vpsm2ctx, const unsigned char *data,
244                                     size_t datalen)
245 {
246     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
247
248     if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
249         return 0;
250
251     return sm2sig_compute_z_digest(psm2ctx)
252         && EVP_DigestUpdate(psm2ctx->mdctx, data, datalen);
253 }
254
255 int sm2sig_digest_sign_final(void *vpsm2ctx, unsigned char *sig, size_t *siglen,
256                              size_t sigsize)
257 {
258     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
259     unsigned char digest[EVP_MAX_MD_SIZE];
260     unsigned int dlen = 0;
261
262     if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
263         return 0;
264
265     /*
266      * If sig is NULL then we're just finding out the sig size. Other fields
267      * are ignored. Defer to sm2sig_sign.
268      */
269     if (sig != NULL) {
270         if (!(sm2sig_compute_z_digest(psm2ctx)
271               && EVP_DigestFinal_ex(psm2ctx->mdctx, digest, &dlen)))
272             return 0;
273     }
274
275     return sm2sig_sign(vpsm2ctx, sig, siglen, sigsize, digest, (size_t)dlen);
276 }
277
278
279 int sm2sig_digest_verify_final(void *vpsm2ctx, const unsigned char *sig,
280                                size_t siglen)
281 {
282     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
283     unsigned char digest[EVP_MAX_MD_SIZE];
284     unsigned int dlen = 0;
285
286     if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
287         return 0;
288
289     /* SM2 always use SM3 so it's not possible to exceed the limit */
290     if (!(sm2sig_compute_z_digest(psm2ctx)
291           && EVP_DigestFinal_ex(psm2ctx->mdctx, digest, &dlen)))
292         return 0;
293
294     return sm2sig_verify(vpsm2ctx, sig, siglen, digest, (size_t)dlen);
295 }
296
297 static void sm2sig_freectx(void *vpsm2ctx)
298 {
299     PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
300
301     free_md(ctx);
302     EC_KEY_free(ctx->ec);
303     OPENSSL_free(ctx->id);
304     OPENSSL_free(ctx);
305 }
306
307 static void *sm2sig_dupctx(void *vpsm2ctx)
308 {
309     PROV_SM2_CTX *srcctx = (PROV_SM2_CTX *)vpsm2ctx;
310     PROV_SM2_CTX *dstctx;
311
312     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
313     if (dstctx == NULL)
314         return NULL;
315
316     *dstctx = *srcctx;
317     dstctx->ec = NULL;
318     dstctx->md = NULL;
319     dstctx->mdctx = NULL;
320
321     if (srcctx->ec != NULL && !EC_KEY_up_ref(srcctx->ec))
322         goto err;
323     dstctx->ec = srcctx->ec;
324
325     if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
326         goto err;
327     dstctx->md = srcctx->md;
328
329     if (srcctx->mdctx != NULL) {
330         dstctx->mdctx = EVP_MD_CTX_new();
331         if (dstctx->mdctx == NULL
332                 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
333             goto err;
334     }
335
336     if (srcctx->id != NULL) {
337         dstctx->id = OPENSSL_malloc(srcctx->id_len);
338         if (dstctx->id == NULL)
339             goto err;
340         dstctx->id_len = srcctx->id_len;
341         memcpy(dstctx->id, srcctx->id, srcctx->id_len);
342     }
343
344     return dstctx;
345  err:
346     sm2sig_freectx(dstctx);
347     return NULL;
348 }
349
350 static int sm2sig_get_ctx_params(void *vpsm2ctx, OSSL_PARAM *params)
351 {
352     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
353     OSSL_PARAM *p;
354
355     if (psm2ctx == NULL || params == NULL)
356         return 0;
357
358     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
359     if (p != NULL
360         && !OSSL_PARAM_set_octet_string(p, psm2ctx->aid, psm2ctx->aid_len))
361         return 0;
362
363     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
364     if (p != NULL && !OSSL_PARAM_set_size_t(p, psm2ctx->mdsize))
365         return 0;
366
367     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
368     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, psm2ctx->md == NULL
369                                                     ? psm2ctx->mdname
370                                                     : EVP_MD_name(psm2ctx->md)))
371         return 0;
372
373     return 1;
374 }
375
376 static const OSSL_PARAM known_gettable_ctx_params[] = {
377     OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
378     OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
379     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
380     OSSL_PARAM_END
381 };
382
383 static const OSSL_PARAM *sm2sig_gettable_ctx_params(ossl_unused void *provctx)
384 {
385     return known_gettable_ctx_params;
386 }
387
388 static int sm2sig_set_ctx_params(void *vpsm2ctx, const OSSL_PARAM params[])
389 {
390     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
391     const OSSL_PARAM *p;
392     char *mdname;
393
394     if (psm2ctx == NULL || params == NULL)
395         return 0;
396
397     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_DIST_ID);
398     if (p != NULL) {
399         void *tmp_id = NULL;
400         size_t tmp_idlen;
401
402         /*
403          * If the 'z' digest has already been computed, the ID is set too late
404          */
405         if (!psm2ctx->flag_compute_z_digest)
406             return 0;
407
408         if (!OSSL_PARAM_get_octet_string(p, &tmp_id, 0, &tmp_idlen))
409             return 0;
410         OPENSSL_free(psm2ctx->id);
411         psm2ctx->id = tmp_id;
412         psm2ctx->id_len = tmp_idlen;
413     }
414
415     if (psm2ctx->md != NULL) {
416         /*
417          * You cannot set the digest name/size when doing a DigestSign or
418          * DigestVerify.
419          */
420         return 1;
421     }
422
423     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
424     if (p != NULL && !OSSL_PARAM_get_size_t(p, &psm2ctx->mdsize))
425         return 0;
426
427     /*
428      * We never actually use the mdname, but we do support getting it later.
429      * This can be useful for applications that want to know the MD that they
430      * previously set.
431      */
432     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
433     mdname = psm2ctx->mdname;
434     if (p != NULL
435             && !OSSL_PARAM_get_utf8_string(p, &mdname, sizeof(psm2ctx->mdname)))
436         return 0;
437
438     return 1;
439 }
440
441 static const OSSL_PARAM known_settable_ctx_params[] = {
442     OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
443     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
444     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DIST_ID, NULL, 0),
445     OSSL_PARAM_END
446 };
447
448 static const OSSL_PARAM *sm2sig_settable_ctx_params(ossl_unused void *provctx)
449 {
450     /*
451      * TODO(3.0): Should this function return a different set of settable ctx
452      * params if the ctx is being used for a DigestSign/DigestVerify? In that
453      * case it is not allowed to set the digest size/digest name because the
454      * digest is explicitly set as part of the init.
455      */
456     return known_settable_ctx_params;
457 }
458
459 static int sm2sig_get_ctx_md_params(void *vpsm2ctx, OSSL_PARAM *params)
460 {
461     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
462
463     if (psm2ctx->mdctx == NULL)
464         return 0;
465
466     return EVP_MD_CTX_get_params(psm2ctx->mdctx, params);
467 }
468
469 static const OSSL_PARAM *sm2sig_gettable_ctx_md_params(void *vpsm2ctx)
470 {
471     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
472
473     if (psm2ctx->md == NULL)
474         return 0;
475
476     return EVP_MD_gettable_ctx_params(psm2ctx->md);
477 }
478
479 static int sm2sig_set_ctx_md_params(void *vpsm2ctx, const OSSL_PARAM params[])
480 {
481     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
482
483     if (psm2ctx->mdctx == NULL)
484         return 0;
485
486     return EVP_MD_CTX_set_params(psm2ctx->mdctx, params);
487 }
488
489 static const OSSL_PARAM *sm2sig_settable_ctx_md_params(void *vpsm2ctx)
490 {
491     PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
492
493     if (psm2ctx->md == NULL)
494         return 0;
495
496     return EVP_MD_settable_ctx_params(psm2ctx->md);
497 }
498
499 const OSSL_DISPATCH sm2_signature_functions[] = {
500     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))sm2sig_newctx },
501     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))sm2sig_signature_init },
502     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))sm2sig_sign },
503     { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))sm2sig_signature_init },
504     { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))sm2sig_verify },
505     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
506       (void (*)(void))sm2sig_digest_signverify_init },
507     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
508       (void (*)(void))sm2sig_digest_signverify_update },
509     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
510       (void (*)(void))sm2sig_digest_sign_final },
511     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
512       (void (*)(void))sm2sig_digest_signverify_init },
513     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
514       (void (*)(void))sm2sig_digest_signverify_update },
515     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
516       (void (*)(void))sm2sig_digest_verify_final },
517     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))sm2sig_freectx },
518     { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))sm2sig_dupctx },
519     { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))sm2sig_get_ctx_params },
520     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
521       (void (*)(void))sm2sig_gettable_ctx_params },
522     { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))sm2sig_set_ctx_params },
523     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
524       (void (*)(void))sm2sig_settable_ctx_params },
525     { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
526       (void (*)(void))sm2sig_get_ctx_md_params },
527     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
528       (void (*)(void))sm2sig_gettable_ctx_md_params },
529     { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
530       (void (*)(void))sm2sig_set_ctx_md_params },
531     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
532       (void (*)(void))sm2sig_settable_ctx_md_params },
533     { 0, NULL }
534 };