KEYS: fix parsing invalid pkey info string
[sfrench/cifs-2.6.git] / security / keys / keyctl_pkey.c
1 /* Public-key operation keyctls
2  *
3  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public Licence
8  * as published by the Free Software Foundation; either version
9  * 2 of the Licence, or (at your option) any later version.
10  */
11
12 #include <linux/slab.h>
13 #include <linux/err.h>
14 #include <linux/key.h>
15 #include <linux/keyctl.h>
16 #include <linux/parser.h>
17 #include <linux/uaccess.h>
18 #include <keys/user-type.h>
19 #include "internal.h"
20
21 static void keyctl_pkey_params_free(struct kernel_pkey_params *params)
22 {
23         kfree(params->info);
24         key_put(params->key);
25 }
26
27 enum {
28         Opt_err,
29         Opt_enc,                /* "enc=<encoding>" eg. "enc=oaep" */
30         Opt_hash,               /* "hash=<digest-name>" eg. "hash=sha1" */
31 };
32
33 static const match_table_t param_keys = {
34         { Opt_enc,      "enc=%s" },
35         { Opt_hash,     "hash=%s" },
36         { Opt_err,      NULL }
37 };
38
39 /*
40  * Parse the information string which consists of key=val pairs.
41  */
42 static int keyctl_pkey_params_parse(struct kernel_pkey_params *params)
43 {
44         unsigned long token_mask = 0;
45         substring_t args[MAX_OPT_ARGS];
46         char *c = params->info, *p, *q;
47         int token;
48
49         while ((p = strsep(&c, " \t"))) {
50                 if (*p == '\0' || *p == ' ' || *p == '\t')
51                         continue;
52                 token = match_token(p, param_keys, args);
53                 if (token == Opt_err)
54                         return -EINVAL;
55                 if (__test_and_set_bit(token, &token_mask))
56                         return -EINVAL;
57                 q = args[0].from;
58                 if (!q[0])
59                         return -EINVAL;
60
61                 switch (token) {
62                 case Opt_enc:
63                         params->encoding = q;
64                         break;
65
66                 case Opt_hash:
67                         params->hash_algo = q;
68                         break;
69
70                 default:
71                         return -EINVAL;
72                 }
73         }
74
75         return 0;
76 }
77
78 /*
79  * Interpret parameters.  Callers must always call the free function
80  * on params, even if an error is returned.
81  */
82 static int keyctl_pkey_params_get(key_serial_t id,
83                                   const char __user *_info,
84                                   struct kernel_pkey_params *params)
85 {
86         key_ref_t key_ref;
87         void *p;
88         int ret;
89
90         memset(params, 0, sizeof(*params));
91         params->encoding = "raw";
92
93         p = strndup_user(_info, PAGE_SIZE);
94         if (IS_ERR(p))
95                 return PTR_ERR(p);
96         params->info = p;
97
98         ret = keyctl_pkey_params_parse(params);
99         if (ret < 0)
100                 return ret;
101
102         key_ref = lookup_user_key(id, 0, KEY_NEED_SEARCH);
103         if (IS_ERR(key_ref))
104                 return PTR_ERR(key_ref);
105         params->key = key_ref_to_ptr(key_ref);
106
107         if (!params->key->type->asym_query)
108                 return -EOPNOTSUPP;
109
110         return 0;
111 }
112
113 /*
114  * Get parameters from userspace.  Callers must always call the free function
115  * on params, even if an error is returned.
116  */
117 static int keyctl_pkey_params_get_2(const struct keyctl_pkey_params __user *_params,
118                                     const char __user *_info,
119                                     int op,
120                                     struct kernel_pkey_params *params)
121 {
122         struct keyctl_pkey_params uparams;
123         struct kernel_pkey_query info;
124         int ret;
125
126         memset(params, 0, sizeof(*params));
127         params->encoding = "raw";
128
129         if (copy_from_user(&uparams, _params, sizeof(uparams)) != 0)
130                 return -EFAULT;
131
132         ret = keyctl_pkey_params_get(uparams.key_id, _info, params);
133         if (ret < 0)
134                 return ret;
135
136         ret = params->key->type->asym_query(params, &info);
137         if (ret < 0)
138                 return ret;
139
140         switch (op) {
141         case KEYCTL_PKEY_ENCRYPT:
142         case KEYCTL_PKEY_DECRYPT:
143                 if (uparams.in_len  > info.max_enc_size ||
144                     uparams.out_len > info.max_dec_size)
145                         return -EINVAL;
146                 break;
147         case KEYCTL_PKEY_SIGN:
148         case KEYCTL_PKEY_VERIFY:
149                 if (uparams.in_len  > info.max_sig_size ||
150                     uparams.out_len > info.max_data_size)
151                         return -EINVAL;
152                 break;
153         default:
154                 BUG();
155         }
156
157         params->in_len  = uparams.in_len;
158         params->out_len = uparams.out_len;
159         return 0;
160 }
161
162 /*
163  * Query information about an asymmetric key.
164  */
165 long keyctl_pkey_query(key_serial_t id,
166                        const char __user *_info,
167                        struct keyctl_pkey_query __user *_res)
168 {
169         struct kernel_pkey_params params;
170         struct kernel_pkey_query res;
171         long ret;
172
173         memset(&params, 0, sizeof(params));
174
175         ret = keyctl_pkey_params_get(id, _info, &params);
176         if (ret < 0)
177                 goto error;
178
179         ret = params.key->type->asym_query(&params, &res);
180         if (ret < 0)
181                 goto error;
182
183         ret = -EFAULT;
184         if (copy_to_user(_res, &res, sizeof(res)) == 0 &&
185             clear_user(_res->__spare, sizeof(_res->__spare)) == 0)
186                 ret = 0;
187
188 error:
189         keyctl_pkey_params_free(&params);
190         return ret;
191 }
192
193 /*
194  * Encrypt/decrypt/sign
195  *
196  * Encrypt data, decrypt data or sign data using a public key.
197  *
198  * _info is a string of supplementary information in key=val format.  For
199  * instance, it might contain:
200  *
201  *      "enc=pkcs1 hash=sha256"
202  *
203  * where enc= specifies the encoding and hash= selects the OID to go in that
204  * particular encoding if required.  If enc= isn't supplied, it's assumed that
205  * the caller is supplying raw values.
206  *
207  * If successful, the amount of data written into the output buffer is
208  * returned.
209  */
210 long keyctl_pkey_e_d_s(int op,
211                        const struct keyctl_pkey_params __user *_params,
212                        const char __user *_info,
213                        const void __user *_in,
214                        void __user *_out)
215 {
216         struct kernel_pkey_params params;
217         void *in, *out;
218         long ret;
219
220         ret = keyctl_pkey_params_get_2(_params, _info, op, &params);
221         if (ret < 0)
222                 goto error_params;
223
224         ret = -EOPNOTSUPP;
225         if (!params.key->type->asym_eds_op)
226                 goto error_params;
227
228         switch (op) {
229         case KEYCTL_PKEY_ENCRYPT:
230                 params.op = kernel_pkey_encrypt;
231                 break;
232         case KEYCTL_PKEY_DECRYPT:
233                 params.op = kernel_pkey_decrypt;
234                 break;
235         case KEYCTL_PKEY_SIGN:
236                 params.op = kernel_pkey_sign;
237                 break;
238         default:
239                 BUG();
240         }
241
242         in = memdup_user(_in, params.in_len);
243         if (IS_ERR(in)) {
244                 ret = PTR_ERR(in);
245                 goto error_params;
246         }
247
248         ret = -ENOMEM;
249         out = kmalloc(params.out_len, GFP_KERNEL);
250         if (!out)
251                 goto error_in;
252
253         ret = params.key->type->asym_eds_op(&params, in, out);
254         if (ret < 0)
255                 goto error_out;
256
257         if (copy_to_user(_out, out, ret) != 0)
258                 ret = -EFAULT;
259
260 error_out:
261         kfree(out);
262 error_in:
263         kfree(in);
264 error_params:
265         keyctl_pkey_params_free(&params);
266         return ret;
267 }
268
269 /*
270  * Verify a signature.
271  *
272  * Verify a public key signature using the given key, or if not given, search
273  * for a matching key.
274  *
275  * _info is a string of supplementary information in key=val format.  For
276  * instance, it might contain:
277  *
278  *      "enc=pkcs1 hash=sha256"
279  *
280  * where enc= specifies the signature blob encoding and hash= selects the OID
281  * to go in that particular encoding.  If enc= isn't supplied, it's assumed
282  * that the caller is supplying raw values.
283  *
284  * If successful, 0 is returned.
285  */
286 long keyctl_pkey_verify(const struct keyctl_pkey_params __user *_params,
287                         const char __user *_info,
288                         const void __user *_in,
289                         const void __user *_in2)
290 {
291         struct kernel_pkey_params params;
292         void *in, *in2;
293         long ret;
294
295         ret = keyctl_pkey_params_get_2(_params, _info, KEYCTL_PKEY_VERIFY,
296                                        &params);
297         if (ret < 0)
298                 goto error_params;
299
300         ret = -EOPNOTSUPP;
301         if (!params.key->type->asym_verify_signature)
302                 goto error_params;
303
304         in = memdup_user(_in, params.in_len);
305         if (IS_ERR(in)) {
306                 ret = PTR_ERR(in);
307                 goto error_params;
308         }
309
310         in2 = memdup_user(_in2, params.in2_len);
311         if (IS_ERR(in2)) {
312                 ret = PTR_ERR(in2);
313                 goto error_in;
314         }
315
316         params.op = kernel_pkey_verify;
317         ret = params.key->type->asym_verify_signature(&params, in, in2);
318
319         kfree(in2);
320 error_in:
321         kfree(in);
322 error_params:
323         keyctl_pkey_params_free(&params);
324         return ret;
325 }