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