Merge tag 'renesas-fixes-for-v6.6-tag3' of git://git.kernel.org/pub/scm/linux/kernel...
[platform/kernel/linux-starfive.git] / crypto / sm2.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * SM2 asymmetric public-key algorithm
4  * as specified by OSCCA GM/T 0003.1-2012 -- 0003.5-2012 SM2 and
5  * described at https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
6  *
7  * Copyright (c) 2020, Alibaba Group.
8  * Authors: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
9  */
10
11 #include <linux/module.h>
12 #include <linux/mpi.h>
13 #include <crypto/internal/akcipher.h>
14 #include <crypto/akcipher.h>
15 #include <crypto/hash.h>
16 #include <crypto/rng.h>
17 #include <crypto/sm2.h>
18 #include "sm2signature.asn1.h"
19
20 /* The default user id as specified in GM/T 0009-2012 */
21 #define SM2_DEFAULT_USERID "1234567812345678"
22 #define SM2_DEFAULT_USERID_LEN 16
23
24 #define MPI_NBYTES(m)   ((mpi_get_nbits(m) + 7) / 8)
25
26 struct ecc_domain_parms {
27         const char *desc;           /* Description of the curve.  */
28         unsigned int nbits;         /* Number of bits.  */
29         unsigned int fips:1; /* True if this is a FIPS140-2 approved curve */
30
31         /* The model describing this curve.  This is mainly used to select
32          * the group equation.
33          */
34         enum gcry_mpi_ec_models model;
35
36         /* The actual ECC dialect used.  This is used for curve specific
37          * optimizations and to select encodings etc.
38          */
39         enum ecc_dialects dialect;
40
41         const char *p;              /* The prime defining the field.  */
42         const char *a, *b;          /* The coefficients.  For Twisted Edwards
43                                      * Curves b is used for d.  For Montgomery
44                                      * Curves (a,b) has ((A-2)/4,B^-1).
45                                      */
46         const char *n;              /* The order of the base point.  */
47         const char *g_x, *g_y;      /* Base point.  */
48         unsigned int h;             /* Cofactor.  */
49 };
50
51 static const struct ecc_domain_parms sm2_ecp = {
52         .desc = "sm2p256v1",
53         .nbits = 256,
54         .fips = 0,
55         .model = MPI_EC_WEIERSTRASS,
56         .dialect = ECC_DIALECT_STANDARD,
57         .p   = "0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff",
58         .a   = "0xfffffffeffffffffffffffffffffffffffffffff00000000fffffffffffffffc",
59         .b   = "0x28e9fa9e9d9f5e344d5a9e4bcf6509a7f39789f515ab8f92ddbcbd414d940e93",
60         .n   = "0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123",
61         .g_x = "0x32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7",
62         .g_y = "0xbc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0",
63         .h = 1
64 };
65
66 static int __sm2_set_pub_key(struct mpi_ec_ctx *ec,
67                              const void *key, unsigned int keylen);
68
69 static int sm2_ec_ctx_init(struct mpi_ec_ctx *ec)
70 {
71         const struct ecc_domain_parms *ecp = &sm2_ecp;
72         MPI p, a, b;
73         MPI x, y;
74         int rc = -EINVAL;
75
76         p = mpi_scanval(ecp->p);
77         a = mpi_scanval(ecp->a);
78         b = mpi_scanval(ecp->b);
79         if (!p || !a || !b)
80                 goto free_p;
81
82         x = mpi_scanval(ecp->g_x);
83         y = mpi_scanval(ecp->g_y);
84         if (!x || !y)
85                 goto free;
86
87         rc = -ENOMEM;
88
89         ec->Q = mpi_point_new(0);
90         if (!ec->Q)
91                 goto free;
92
93         /* mpi_ec_setup_elliptic_curve */
94         ec->G = mpi_point_new(0);
95         if (!ec->G) {
96                 mpi_point_release(ec->Q);
97                 goto free;
98         }
99
100         mpi_set(ec->G->x, x);
101         mpi_set(ec->G->y, y);
102         mpi_set_ui(ec->G->z, 1);
103
104         rc = -EINVAL;
105         ec->n = mpi_scanval(ecp->n);
106         if (!ec->n) {
107                 mpi_point_release(ec->Q);
108                 mpi_point_release(ec->G);
109                 goto free;
110         }
111
112         ec->h = ecp->h;
113         ec->name = ecp->desc;
114         mpi_ec_init(ec, ecp->model, ecp->dialect, 0, p, a, b);
115
116         rc = 0;
117
118 free:
119         mpi_free(x);
120         mpi_free(y);
121 free_p:
122         mpi_free(p);
123         mpi_free(a);
124         mpi_free(b);
125
126         return rc;
127 }
128
129 static void sm2_ec_ctx_deinit(struct mpi_ec_ctx *ec)
130 {
131         mpi_ec_deinit(ec);
132
133         memset(ec, 0, sizeof(*ec));
134 }
135
136 /* RESULT must have been initialized and is set on success to the
137  * point given by VALUE.
138  */
139 static int sm2_ecc_os2ec(MPI_POINT result, MPI value)
140 {
141         int rc;
142         size_t n;
143         unsigned char *buf;
144         MPI x, y;
145
146         n = MPI_NBYTES(value);
147         buf = kmalloc(n, GFP_KERNEL);
148         if (!buf)
149                 return -ENOMEM;
150
151         rc = mpi_print(GCRYMPI_FMT_USG, buf, n, &n, value);
152         if (rc)
153                 goto err_freebuf;
154
155         rc = -EINVAL;
156         if (n < 1 || ((n - 1) % 2))
157                 goto err_freebuf;
158         /* No support for point compression */
159         if (*buf != 0x4)
160                 goto err_freebuf;
161
162         rc = -ENOMEM;
163         n = (n - 1) / 2;
164         x = mpi_read_raw_data(buf + 1, n);
165         if (!x)
166                 goto err_freebuf;
167         y = mpi_read_raw_data(buf + 1 + n, n);
168         if (!y)
169                 goto err_freex;
170
171         mpi_normalize(x);
172         mpi_normalize(y);
173         mpi_set(result->x, x);
174         mpi_set(result->y, y);
175         mpi_set_ui(result->z, 1);
176
177         rc = 0;
178
179         mpi_free(y);
180 err_freex:
181         mpi_free(x);
182 err_freebuf:
183         kfree(buf);
184         return rc;
185 }
186
187 struct sm2_signature_ctx {
188         MPI sig_r;
189         MPI sig_s;
190 };
191
192 int sm2_get_signature_r(void *context, size_t hdrlen, unsigned char tag,
193                                 const void *value, size_t vlen)
194 {
195         struct sm2_signature_ctx *sig = context;
196
197         if (!value || !vlen)
198                 return -EINVAL;
199
200         sig->sig_r = mpi_read_raw_data(value, vlen);
201         if (!sig->sig_r)
202                 return -ENOMEM;
203
204         return 0;
205 }
206
207 int sm2_get_signature_s(void *context, size_t hdrlen, unsigned char tag,
208                                 const void *value, size_t vlen)
209 {
210         struct sm2_signature_ctx *sig = context;
211
212         if (!value || !vlen)
213                 return -EINVAL;
214
215         sig->sig_s = mpi_read_raw_data(value, vlen);
216         if (!sig->sig_s)
217                 return -ENOMEM;
218
219         return 0;
220 }
221
222 static int sm2_z_digest_update(struct shash_desc *desc,
223                                MPI m, unsigned int pbytes)
224 {
225         static const unsigned char zero[32];
226         unsigned char *in;
227         unsigned int inlen;
228         int err;
229
230         in = mpi_get_buffer(m, &inlen, NULL);
231         if (!in)
232                 return -EINVAL;
233
234         if (inlen < pbytes) {
235                 /* padding with zero */
236                 err = crypto_shash_update(desc, zero, pbytes - inlen) ?:
237                       crypto_shash_update(desc, in, inlen);
238         } else if (inlen > pbytes) {
239                 /* skip the starting zero */
240                 err = crypto_shash_update(desc, in + inlen - pbytes, pbytes);
241         } else {
242                 err = crypto_shash_update(desc, in, inlen);
243         }
244
245         kfree(in);
246         return err;
247 }
248
249 static int sm2_z_digest_update_point(struct shash_desc *desc,
250                                      MPI_POINT point, struct mpi_ec_ctx *ec,
251                                      unsigned int pbytes)
252 {
253         MPI x, y;
254         int ret = -EINVAL;
255
256         x = mpi_new(0);
257         y = mpi_new(0);
258
259         ret = mpi_ec_get_affine(x, y, point, ec) ? -EINVAL :
260               sm2_z_digest_update(desc, x, pbytes) ?:
261               sm2_z_digest_update(desc, y, pbytes);
262
263         mpi_free(x);
264         mpi_free(y);
265         return ret;
266 }
267
268 int sm2_compute_z_digest(struct shash_desc *desc,
269                          const void *key, unsigned int keylen, void *dgst)
270 {
271         struct mpi_ec_ctx *ec;
272         unsigned int bits_len;
273         unsigned int pbytes;
274         u8 entl[2];
275         int err;
276
277         ec = kmalloc(sizeof(*ec), GFP_KERNEL);
278         if (!ec)
279                 return -ENOMEM;
280
281         err = sm2_ec_ctx_init(ec);
282         if (err)
283                 goto out_free_ec;
284
285         err = __sm2_set_pub_key(ec, key, keylen);
286         if (err)
287                 goto out_deinit_ec;
288
289         bits_len = SM2_DEFAULT_USERID_LEN * 8;
290         entl[0] = bits_len >> 8;
291         entl[1] = bits_len & 0xff;
292
293         pbytes = MPI_NBYTES(ec->p);
294
295         /* ZA = H256(ENTLA | IDA | a | b | xG | yG | xA | yA) */
296         err = crypto_shash_init(desc);
297         if (err)
298                 goto out_deinit_ec;
299
300         err = crypto_shash_update(desc, entl, 2);
301         if (err)
302                 goto out_deinit_ec;
303
304         err = crypto_shash_update(desc, SM2_DEFAULT_USERID,
305                                   SM2_DEFAULT_USERID_LEN);
306         if (err)
307                 goto out_deinit_ec;
308
309         err = sm2_z_digest_update(desc, ec->a, pbytes) ?:
310               sm2_z_digest_update(desc, ec->b, pbytes) ?:
311               sm2_z_digest_update_point(desc, ec->G, ec, pbytes) ?:
312               sm2_z_digest_update_point(desc, ec->Q, ec, pbytes);
313         if (err)
314                 goto out_deinit_ec;
315
316         err = crypto_shash_final(desc, dgst);
317
318 out_deinit_ec:
319         sm2_ec_ctx_deinit(ec);
320 out_free_ec:
321         kfree(ec);
322         return err;
323 }
324 EXPORT_SYMBOL_GPL(sm2_compute_z_digest);
325
326 static int _sm2_verify(struct mpi_ec_ctx *ec, MPI hash, MPI sig_r, MPI sig_s)
327 {
328         int rc = -EINVAL;
329         struct gcry_mpi_point sG, tP;
330         MPI t = NULL;
331         MPI x1 = NULL, y1 = NULL;
332
333         mpi_point_init(&sG);
334         mpi_point_init(&tP);
335         x1 = mpi_new(0);
336         y1 = mpi_new(0);
337         t = mpi_new(0);
338
339         /* r, s in [1, n-1] */
340         if (mpi_cmp_ui(sig_r, 1) < 0 || mpi_cmp(sig_r, ec->n) > 0 ||
341                 mpi_cmp_ui(sig_s, 1) < 0 || mpi_cmp(sig_s, ec->n) > 0) {
342                 goto leave;
343         }
344
345         /* t = (r + s) % n, t == 0 */
346         mpi_addm(t, sig_r, sig_s, ec->n);
347         if (mpi_cmp_ui(t, 0) == 0)
348                 goto leave;
349
350         /* sG + tP = (x1, y1) */
351         rc = -EBADMSG;
352         mpi_ec_mul_point(&sG, sig_s, ec->G, ec);
353         mpi_ec_mul_point(&tP, t, ec->Q, ec);
354         mpi_ec_add_points(&sG, &sG, &tP, ec);
355         if (mpi_ec_get_affine(x1, y1, &sG, ec))
356                 goto leave;
357
358         /* R = (e + x1) % n */
359         mpi_addm(t, hash, x1, ec->n);
360
361         /* check R == r */
362         rc = -EKEYREJECTED;
363         if (mpi_cmp(t, sig_r))
364                 goto leave;
365
366         rc = 0;
367
368 leave:
369         mpi_point_free_parts(&sG);
370         mpi_point_free_parts(&tP);
371         mpi_free(x1);
372         mpi_free(y1);
373         mpi_free(t);
374
375         return rc;
376 }
377
378 static int sm2_verify(struct akcipher_request *req)
379 {
380         struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
381         struct mpi_ec_ctx *ec = akcipher_tfm_ctx(tfm);
382         unsigned char *buffer;
383         struct sm2_signature_ctx sig;
384         MPI hash;
385         int ret;
386
387         if (unlikely(!ec->Q))
388                 return -EINVAL;
389
390         buffer = kmalloc(req->src_len + req->dst_len, GFP_KERNEL);
391         if (!buffer)
392                 return -ENOMEM;
393
394         sg_pcopy_to_buffer(req->src,
395                 sg_nents_for_len(req->src, req->src_len + req->dst_len),
396                 buffer, req->src_len + req->dst_len, 0);
397
398         sig.sig_r = NULL;
399         sig.sig_s = NULL;
400         ret = asn1_ber_decoder(&sm2signature_decoder, &sig,
401                                 buffer, req->src_len);
402         if (ret)
403                 goto error;
404
405         ret = -ENOMEM;
406         hash = mpi_read_raw_data(buffer + req->src_len, req->dst_len);
407         if (!hash)
408                 goto error;
409
410         ret = _sm2_verify(ec, hash, sig.sig_r, sig.sig_s);
411
412         mpi_free(hash);
413 error:
414         mpi_free(sig.sig_r);
415         mpi_free(sig.sig_s);
416         kfree(buffer);
417         return ret;
418 }
419
420 static int sm2_set_pub_key(struct crypto_akcipher *tfm,
421                         const void *key, unsigned int keylen)
422 {
423         struct mpi_ec_ctx *ec = akcipher_tfm_ctx(tfm);
424
425         return __sm2_set_pub_key(ec, key, keylen);
426
427 }
428
429 static int __sm2_set_pub_key(struct mpi_ec_ctx *ec,
430                              const void *key, unsigned int keylen)
431 {
432         MPI a;
433         int rc;
434
435         /* include the uncompressed flag '0x04' */
436         a = mpi_read_raw_data(key, keylen);
437         if (!a)
438                 return -ENOMEM;
439
440         mpi_normalize(a);
441         rc = sm2_ecc_os2ec(ec->Q, a);
442         mpi_free(a);
443
444         return rc;
445 }
446
447 static unsigned int sm2_max_size(struct crypto_akcipher *tfm)
448 {
449         /* Unlimited max size */
450         return PAGE_SIZE;
451 }
452
453 static int sm2_init_tfm(struct crypto_akcipher *tfm)
454 {
455         struct mpi_ec_ctx *ec = akcipher_tfm_ctx(tfm);
456
457         return sm2_ec_ctx_init(ec);
458 }
459
460 static void sm2_exit_tfm(struct crypto_akcipher *tfm)
461 {
462         struct mpi_ec_ctx *ec = akcipher_tfm_ctx(tfm);
463
464         sm2_ec_ctx_deinit(ec);
465 }
466
467 static struct akcipher_alg sm2 = {
468         .verify = sm2_verify,
469         .set_pub_key = sm2_set_pub_key,
470         .max_size = sm2_max_size,
471         .init = sm2_init_tfm,
472         .exit = sm2_exit_tfm,
473         .base = {
474                 .cra_name = "sm2",
475                 .cra_driver_name = "sm2-generic",
476                 .cra_priority = 100,
477                 .cra_module = THIS_MODULE,
478                 .cra_ctxsize = sizeof(struct mpi_ec_ctx),
479         },
480 };
481
482 static int __init sm2_init(void)
483 {
484         return crypto_register_akcipher(&sm2);
485 }
486
487 static void __exit sm2_exit(void)
488 {
489         crypto_unregister_akcipher(&sm2);
490 }
491
492 subsys_initcall(sm2_init);
493 module_exit(sm2_exit);
494
495 MODULE_LICENSE("GPL");
496 MODULE_AUTHOR("Tianjia Zhang <tianjia.zhang@linux.alibaba.com>");
497 MODULE_DESCRIPTION("SM2 generic algorithm");
498 MODULE_ALIAS_CRYPTO("sm2-generic");