1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* In-software asymmetric public-key crypto subtype
3 *
4 * See Documentation/crypto/asymmetric-keys.txt
5 *
6 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
7 * Written by David Howells (dhowells@redhat.com)
8 */
9
10 #define pr_fmt(fmt) "PKEY: "fmt
11 #ifdef __UBOOT__
12 #include <dm/devres.h>
13 #include <linux/bug.h>
14 #include <linux/compat.h>
15 #include <linux/err.h>
16 #else
17 #include <linux/module.h>
18 #include <linux/export.h>
19 #endif
20 #include <linux/kernel.h>
21 #ifndef __UBOOT__
22 #include <linux/slab.h>
23 #include <linux/seq_file.h>
24 #include <linux/scatterlist.h>
25 #include <keys/asymmetric-subtype.h>
26 #endif
27 #include <crypto/public_key.h>
28 #ifndef __UBOOT__
29 #include <crypto/akcipher.h>
30 #endif
31
32 MODULE_DESCRIPTION("In-software asymmetric public-key subtype");
33 MODULE_AUTHOR("Red Hat, Inc.");
34 MODULE_LICENSE("GPL");
35
36 #ifndef __UBOOT__
37 /*
38 * Provide a part of a description of the key for /proc/keys.
39 */
public_key_describe(const struct key * asymmetric_key,struct seq_file * m)40 static void public_key_describe(const struct key *asymmetric_key,
41 struct seq_file *m)
42 {
43 struct public_key *key = asymmetric_key->payload.data[asym_crypto];
44
45 if (key)
46 seq_printf(m, "%s.%s", key->id_type, key->pkey_algo);
47 }
48 #endif
49
50 /*
51 * Destroy a public key algorithm key.
52 */
public_key_free(struct public_key * key)53 void public_key_free(struct public_key *key)
54 {
55 if (key) {
56 kfree(key->key);
57 kfree(key->params);
58 kfree(key);
59 }
60 }
61 EXPORT_SYMBOL_GPL(public_key_free);
62
63 #ifdef __UBOOT__
64 /*
65 * from <linux>/crypto/asymmetric_keys/signature.c
66 *
67 * Destroy a public key signature.
68 */
public_key_signature_free(struct public_key_signature * sig)69 void public_key_signature_free(struct public_key_signature *sig)
70 {
71 int i;
72
73 if (sig) {
74 for (i = 0; i < ARRAY_SIZE(sig->auth_ids); i++)
75 free(sig->auth_ids[i]);
76 free(sig->s);
77 free(sig->digest);
78 free(sig);
79 }
80 }
81 EXPORT_SYMBOL_GPL(public_key_signature_free);
82
83 #else
84 /*
85 * Destroy a public key algorithm key.
86 */
public_key_destroy(void * payload0,void * payload3)87 static void public_key_destroy(void *payload0, void *payload3)
88 {
89 public_key_free(payload0);
90 public_key_signature_free(payload3);
91 }
92
93 /*
94 * Determine the crypto algorithm name.
95 */
96 static
software_key_determine_akcipher(const char * encoding,const char * hash_algo,const struct public_key * pkey,char alg_name[CRYPTO_MAX_ALG_NAME])97 int software_key_determine_akcipher(const char *encoding,
98 const char *hash_algo,
99 const struct public_key *pkey,
100 char alg_name[CRYPTO_MAX_ALG_NAME])
101 {
102 int n;
103
104 if (strcmp(encoding, "pkcs1") == 0) {
105 /* The data wangled by the RSA algorithm is typically padded
106 * and encoded in some manner, such as EMSA-PKCS1-1_5 [RFC3447
107 * sec 8.2].
108 */
109 if (!hash_algo)
110 n = snprintf(alg_name, CRYPTO_MAX_ALG_NAME,
111 "pkcs1pad(%s)",
112 pkey->pkey_algo);
113 else
114 n = snprintf(alg_name, CRYPTO_MAX_ALG_NAME,
115 "pkcs1pad(%s,%s)",
116 pkey->pkey_algo, hash_algo);
117 return n >= CRYPTO_MAX_ALG_NAME ? -EINVAL : 0;
118 }
119
120 if (strcmp(encoding, "raw") == 0) {
121 strcpy(alg_name, pkey->pkey_algo);
122 return 0;
123 }
124
125 return -ENOPKG;
126 }
127
pkey_pack_u32(u8 * dst,u32 val)128 static u8 *pkey_pack_u32(u8 *dst, u32 val)
129 {
130 memcpy(dst, &val, sizeof(val));
131 return dst + sizeof(val);
132 }
133
134 /*
135 * Query information about a key.
136 */
software_key_query(const struct kernel_pkey_params * params,struct kernel_pkey_query * info)137 static int software_key_query(const struct kernel_pkey_params *params,
138 struct kernel_pkey_query *info)
139 {
140 struct crypto_akcipher *tfm;
141 struct public_key *pkey = params->key->payload.data[asym_crypto];
142 char alg_name[CRYPTO_MAX_ALG_NAME];
143 u8 *key, *ptr;
144 int ret, len;
145
146 ret = software_key_determine_akcipher(params->encoding,
147 params->hash_algo,
148 pkey, alg_name);
149 if (ret < 0)
150 return ret;
151
152 tfm = crypto_alloc_akcipher(alg_name, 0, 0);
153 if (IS_ERR(tfm))
154 return PTR_ERR(tfm);
155
156 key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
157 GFP_KERNEL);
158 if (!key)
159 goto error_free_tfm;
160 memcpy(key, pkey->key, pkey->keylen);
161 ptr = key + pkey->keylen;
162 ptr = pkey_pack_u32(ptr, pkey->algo);
163 ptr = pkey_pack_u32(ptr, pkey->paramlen);
164 memcpy(ptr, pkey->params, pkey->paramlen);
165
166 if (pkey->key_is_private)
167 ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
168 else
169 ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
170 if (ret < 0)
171 goto error_free_key;
172
173 len = crypto_akcipher_maxsize(tfm);
174 info->key_size = len * 8;
175 info->max_data_size = len;
176 info->max_sig_size = len;
177 info->max_enc_size = len;
178 info->max_dec_size = len;
179 info->supported_ops = (KEYCTL_SUPPORTS_ENCRYPT |
180 KEYCTL_SUPPORTS_VERIFY);
181 if (pkey->key_is_private)
182 info->supported_ops |= (KEYCTL_SUPPORTS_DECRYPT |
183 KEYCTL_SUPPORTS_SIGN);
184 ret = 0;
185
186 error_free_key:
187 kfree(key);
188 error_free_tfm:
189 crypto_free_akcipher(tfm);
190 pr_devel("<==%s() = %d\n", __func__, ret);
191 return ret;
192 }
193
194 /*
195 * Do encryption, decryption and signing ops.
196 */
software_key_eds_op(struct kernel_pkey_params * params,const void * in,void * out)197 static int software_key_eds_op(struct kernel_pkey_params *params,
198 const void *in, void *out)
199 {
200 const struct public_key *pkey = params->key->payload.data[asym_crypto];
201 struct akcipher_request *req;
202 struct crypto_akcipher *tfm;
203 struct crypto_wait cwait;
204 struct scatterlist in_sg, out_sg;
205 char alg_name[CRYPTO_MAX_ALG_NAME];
206 char *key, *ptr;
207 int ret;
208
209 pr_devel("==>%s()\n", __func__);
210
211 ret = software_key_determine_akcipher(params->encoding,
212 params->hash_algo,
213 pkey, alg_name);
214 if (ret < 0)
215 return ret;
216
217 tfm = crypto_alloc_akcipher(alg_name, 0, 0);
218 if (IS_ERR(tfm))
219 return PTR_ERR(tfm);
220
221 req = akcipher_request_alloc(tfm, GFP_KERNEL);
222 if (!req)
223 goto error_free_tfm;
224
225 key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
226 GFP_KERNEL);
227 if (!key)
228 goto error_free_req;
229
230 memcpy(key, pkey->key, pkey->keylen);
231 ptr = key + pkey->keylen;
232 ptr = pkey_pack_u32(ptr, pkey->algo);
233 ptr = pkey_pack_u32(ptr, pkey->paramlen);
234 memcpy(ptr, pkey->params, pkey->paramlen);
235
236 if (pkey->key_is_private)
237 ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
238 else
239 ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
240 if (ret)
241 goto error_free_key;
242
243 sg_init_one(&in_sg, in, params->in_len);
244 sg_init_one(&out_sg, out, params->out_len);
245 akcipher_request_set_crypt(req, &in_sg, &out_sg, params->in_len,
246 params->out_len);
247 crypto_init_wait(&cwait);
248 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
249 CRYPTO_TFM_REQ_MAY_SLEEP,
250 crypto_req_done, &cwait);
251
252 /* Perform the encryption calculation. */
253 switch (params->op) {
254 case kernel_pkey_encrypt:
255 ret = crypto_akcipher_encrypt(req);
256 break;
257 case kernel_pkey_decrypt:
258 ret = crypto_akcipher_decrypt(req);
259 break;
260 case kernel_pkey_sign:
261 ret = crypto_akcipher_sign(req);
262 break;
263 default:
264 BUG();
265 }
266
267 ret = crypto_wait_req(ret, &cwait);
268 if (ret == 0)
269 ret = req->dst_len;
270
271 error_free_key:
272 kfree(key);
273 error_free_req:
274 akcipher_request_free(req);
275 error_free_tfm:
276 crypto_free_akcipher(tfm);
277 pr_devel("<==%s() = %d\n", __func__, ret);
278 return ret;
279 }
280
281 /*
282 * Verify a signature using a public key.
283 */
public_key_verify_signature(const struct public_key * pkey,const struct public_key_signature * sig)284 int public_key_verify_signature(const struct public_key *pkey,
285 const struct public_key_signature *sig)
286 {
287 struct crypto_wait cwait;
288 struct crypto_akcipher *tfm;
289 struct akcipher_request *req;
290 struct scatterlist src_sg[2];
291 char alg_name[CRYPTO_MAX_ALG_NAME];
292 char *key, *ptr;
293 int ret;
294
295 pr_devel("==>%s()\n", __func__);
296
297 BUG_ON(!pkey);
298 BUG_ON(!sig);
299 BUG_ON(!sig->s);
300
301 ret = software_key_determine_akcipher(sig->encoding,
302 sig->hash_algo,
303 pkey, alg_name);
304 if (ret < 0)
305 return ret;
306
307 tfm = crypto_alloc_akcipher(alg_name, 0, 0);
308 if (IS_ERR(tfm))
309 return PTR_ERR(tfm);
310
311 ret = -ENOMEM;
312 req = akcipher_request_alloc(tfm, GFP_KERNEL);
313 if (!req)
314 goto error_free_tfm;
315
316 key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
317 GFP_KERNEL);
318 if (!key)
319 goto error_free_req;
320
321 memcpy(key, pkey->key, pkey->keylen);
322 ptr = key + pkey->keylen;
323 ptr = pkey_pack_u32(ptr, pkey->algo);
324 ptr = pkey_pack_u32(ptr, pkey->paramlen);
325 memcpy(ptr, pkey->params, pkey->paramlen);
326
327 if (pkey->key_is_private)
328 ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
329 else
330 ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
331 if (ret)
332 goto error_free_key;
333
334 sg_init_table(src_sg, 2);
335 sg_set_buf(&src_sg[0], sig->s, sig->s_size);
336 sg_set_buf(&src_sg[1], sig->digest, sig->digest_size);
337 akcipher_request_set_crypt(req, src_sg, NULL, sig->s_size,
338 sig->digest_size);
339 crypto_init_wait(&cwait);
340 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
341 CRYPTO_TFM_REQ_MAY_SLEEP,
342 crypto_req_done, &cwait);
343 ret = crypto_wait_req(crypto_akcipher_verify(req), &cwait);
344
345 error_free_key:
346 kfree(key);
347 error_free_req:
348 akcipher_request_free(req);
349 error_free_tfm:
350 crypto_free_akcipher(tfm);
351 pr_devel("<==%s() = %d\n", __func__, ret);
352 if (WARN_ON_ONCE(ret > 0))
353 ret = -EINVAL;
354 return ret;
355 }
356 EXPORT_SYMBOL_GPL(public_key_verify_signature);
357
public_key_verify_signature_2(const struct key * key,const struct public_key_signature * sig)358 static int public_key_verify_signature_2(const struct key *key,
359 const struct public_key_signature *sig)
360 {
361 const struct public_key *pk = key->payload.data[asym_crypto];
362 return public_key_verify_signature(pk, sig);
363 }
364
365 /*
366 * Public key algorithm asymmetric key subtype
367 */
368 struct asymmetric_key_subtype public_key_subtype = {
369 .owner = THIS_MODULE,
370 .name = "public_key",
371 .name_len = sizeof("public_key") - 1,
372 .describe = public_key_describe,
373 .destroy = public_key_destroy,
374 .query = software_key_query,
375 .eds_op = software_key_eds_op,
376 .verify_signature = public_key_verify_signature_2,
377 };
378 EXPORT_SYMBOL_GPL(public_key_subtype);
379 #endif /* !__UBOOT__ */
380