1 /* In-software asymmetric public-key crypto subtype
2  *
3  * See Documentation/crypto/asymmetric-keys.txt
4  *
5  * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
6  * Written by David Howells (dhowells@redhat.com)
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public Licence
10  * as published by the Free Software Foundation; either version
11  * 2 of the Licence, or (at your option) any later version.
12  */
13 
14 #define pr_fmt(fmt) "PKEY: "fmt
15 #include <linux/module.h>
16 #include <linux/export.h>
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/seq_file.h>
20 #include <linux/scatterlist.h>
21 #include <keys/asymmetric-subtype.h>
22 #include <crypto/public_key.h>
23 #include <crypto/akcipher.h>
24 
25 MODULE_DESCRIPTION("In-software asymmetric public-key subtype");
26 MODULE_AUTHOR("Red Hat, Inc.");
27 MODULE_LICENSE("GPL");
28 
29 /*
30  * Provide a part of a description of the key for /proc/keys.
31  */
32 static void public_key_describe(const struct key *asymmetric_key,
33 				struct seq_file *m)
34 {
35 	struct public_key *key = asymmetric_key->payload.data[asym_crypto];
36 
37 	if (key)
38 		seq_printf(m, "%s.%s", key->id_type, key->pkey_algo);
39 }
40 
41 /*
42  * Destroy a public key algorithm key.
43  */
44 void public_key_free(struct public_key *key)
45 {
46 	if (key) {
47 		kfree(key->key);
48 		kfree(key);
49 	}
50 }
51 EXPORT_SYMBOL_GPL(public_key_free);
52 
53 /*
54  * Destroy a public key algorithm key.
55  */
56 static void public_key_destroy(void *payload0, void *payload3)
57 {
58 	public_key_free(payload0);
59 	public_key_signature_free(payload3);
60 }
61 
62 /*
63  * Verify a signature using a public key.
64  */
65 int public_key_verify_signature(const struct public_key *pkey,
66 				const struct public_key_signature *sig)
67 {
68 	struct crypto_wait cwait;
69 	struct crypto_akcipher *tfm;
70 	struct akcipher_request *req;
71 	struct scatterlist sig_sg, digest_sg;
72 	const char *alg_name;
73 	char alg_name_buf[CRYPTO_MAX_ALG_NAME];
74 	void *output;
75 	unsigned int outlen;
76 	int ret;
77 
78 	pr_devel("==>%s()\n", __func__);
79 
80 	BUG_ON(!pkey);
81 	BUG_ON(!sig);
82 	BUG_ON(!sig->s);
83 
84 	if (!sig->digest)
85 		return -ENOPKG;
86 
87 	alg_name = sig->pkey_algo;
88 	if (strcmp(sig->pkey_algo, "rsa") == 0) {
89 		/* The data wangled by the RSA algorithm is typically padded
90 		 * and encoded in some manner, such as EMSA-PKCS1-1_5 [RFC3447
91 		 * sec 8.2].
92 		 */
93 		if (snprintf(alg_name_buf, CRYPTO_MAX_ALG_NAME,
94 			     "pkcs1pad(rsa,%s)", sig->hash_algo
95 			     ) >= CRYPTO_MAX_ALG_NAME)
96 			return -EINVAL;
97 		alg_name = alg_name_buf;
98 	}
99 
100 	tfm = crypto_alloc_akcipher(alg_name, 0, 0);
101 	if (IS_ERR(tfm))
102 		return PTR_ERR(tfm);
103 
104 	ret = -ENOMEM;
105 	req = akcipher_request_alloc(tfm, GFP_KERNEL);
106 	if (!req)
107 		goto error_free_tfm;
108 
109 	ret = crypto_akcipher_set_pub_key(tfm, pkey->key, pkey->keylen);
110 	if (ret)
111 		goto error_free_req;
112 
113 	ret = -ENOMEM;
114 	outlen = crypto_akcipher_maxsize(tfm);
115 	output = kmalloc(outlen, GFP_KERNEL);
116 	if (!output)
117 		goto error_free_req;
118 
119 	sg_init_one(&sig_sg, sig->s, sig->s_size);
120 	sg_init_one(&digest_sg, output, outlen);
121 	akcipher_request_set_crypt(req, &sig_sg, &digest_sg, sig->s_size,
122 				   outlen);
123 	crypto_init_wait(&cwait);
124 	akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
125 				      CRYPTO_TFM_REQ_MAY_SLEEP,
126 				      crypto_req_done, &cwait);
127 
128 	/* Perform the verification calculation.  This doesn't actually do the
129 	 * verification, but rather calculates the hash expected by the
130 	 * signature and returns that to us.
131 	 */
132 	ret = crypto_wait_req(crypto_akcipher_verify(req), &cwait);
133 	if (ret)
134 		goto out_free_output;
135 
136 	/* Do the actual verification step. */
137 	if (req->dst_len != sig->digest_size ||
138 	    memcmp(sig->digest, output, sig->digest_size) != 0)
139 		ret = -EKEYREJECTED;
140 
141 out_free_output:
142 	kfree(output);
143 error_free_req:
144 	akcipher_request_free(req);
145 error_free_tfm:
146 	crypto_free_akcipher(tfm);
147 	pr_devel("<==%s() = %d\n", __func__, ret);
148 	if (WARN_ON_ONCE(ret > 0))
149 		ret = -EINVAL;
150 	return ret;
151 }
152 EXPORT_SYMBOL_GPL(public_key_verify_signature);
153 
154 static int public_key_verify_signature_2(const struct key *key,
155 					 const struct public_key_signature *sig)
156 {
157 	const struct public_key *pk = key->payload.data[asym_crypto];
158 	return public_key_verify_signature(pk, sig);
159 }
160 
161 /*
162  * Public key algorithm asymmetric key subtype
163  */
164 struct asymmetric_key_subtype public_key_subtype = {
165 	.owner			= THIS_MODULE,
166 	.name			= "public_key",
167 	.name_len		= sizeof("public_key") - 1,
168 	.describe		= public_key_describe,
169 	.destroy		= public_key_destroy,
170 	.verify_signature	= public_key_verify_signature_2,
171 };
172 EXPORT_SYMBOL_GPL(public_key_subtype);
173