projects/linux·blob master · refs

494 lines · 10.2 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * algif_hash: User-space interface for hash algorithms
4 *
5 * This file provides the user-space API for hash algorithms.
6 *
7 * Copyright (c) 2010 Herbert Xu <[email protected]>
8 */
9
10#include <crypto/hash.h>
11#include <crypto/if_alg.h>
12#include <linux/init.h>
13#include <linux/kernel.h>
14#include <linux/mm.h>
15#include <linux/module.h>
16#include <linux/net.h>
17#include <net/sock.h>
18
19static const struct af_alg_allowlist_entry hash_allowlist[] = {
20 { "cmac(aes)" }, /* iwd, bluez */
21 { "hmac(md5)" }, /* iwd */
22 { "hmac(sha1)" }, /* iwd */
23 { "hmac(sha224)" }, /* iwd */
24 { "hmac(sha256)" }, /* iwd */
25 { "hmac(sha384)" }, /* iwd */
26 { "hmac(sha512)" }, /* iwd, sha512hmac */
27 { "md4" }, /* iwd */
28 { "md5" }, /* iwd */
29 { "sha1", AF_ALG_UNPRIVILEGED }, /* iwd, iproute2 < 7.0 */
30 { "sha224" }, /* iwd */
31 { "sha256" }, /* iwd */
32 { "sha384" }, /* iwd */
33 { "sha512" }, /* iwd */
34 {},
35};
36
37struct hash_ctx {
38 struct af_alg_sgl sgl;
39
40 u8 *result;
41
42 struct crypto_wait wait;
43
44 unsigned int len;
45 bool more;
46
47 struct ahash_request req;
48};
49
50static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx)
51{
52 unsigned ds;
53
54 if (ctx->result)
55 return 0;
56
57 ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
58
59 ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL);
60 if (!ctx->result)
61 return -ENOMEM;
62
63 memset(ctx->result, 0, ds);
64
65 return 0;
66}
67
68static void hash_free_result(struct sock *sk, struct hash_ctx *ctx)
69{
70 unsigned ds;
71
72 if (!ctx->result)
73 return;
74
75 ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
76
77 sock_kzfree_s(sk, ctx->result, ds);
78 ctx->result = NULL;
79}
80
81static int hash_sendmsg(struct socket *sock, struct msghdr *msg,
82 size_t ignored)
83{
84 struct sock *sk = sock->sk;
85 struct alg_sock *ask = alg_sk(sk);
86 struct hash_ctx *ctx = ask->private;
87 ssize_t copied = 0;
88 size_t len, max_pages, npages;
89 bool continuing, need_init = false;
90 int err;
91
92 max_pages = min_t(size_t, ALG_MAX_PAGES,
93 DIV_ROUND_UP(sk->sk_sndbuf, PAGE_SIZE));
94
95 lock_sock(sk);
96 continuing = ctx->more;
97
98 if (!continuing) {
99 /* Discard a previous request that wasn't marked MSG_MORE. */
100 hash_free_result(sk, ctx);
101 if (!msg_data_left(msg))
102 goto done; /* Zero-length; don't start new req */
103 need_init = true;
104 } else if (!msg_data_left(msg)) {
105 /*
106 * No data - finalise the prev req if MSG_MORE so any error
107 * comes out here.
108 */
109 if (!(msg->msg_flags & MSG_MORE)) {
110 err = hash_alloc_result(sk, ctx);
111 if (err)
112 goto unlock_free_result;
113 ahash_request_set_crypt(&ctx->req, NULL,
114 ctx->result, 0);
115 err = crypto_wait_req(crypto_ahash_final(&ctx->req),
116 &ctx->wait);
117 if (err)
118 goto unlock_free_result;
119 }
120 goto done_more;
121 }
122
123 while (msg_data_left(msg)) {
124 ctx->sgl.sgt.sgl = ctx->sgl.sgl;
125 ctx->sgl.sgt.nents = 0;
126 ctx->sgl.sgt.orig_nents = 0;
127
128 err = -EIO;
129 npages = iov_iter_npages(&msg->msg_iter, max_pages);
130 if (npages == 0)
131 goto unlock_free;
132
133 sg_init_table(ctx->sgl.sgl, npages);
134
135 ctx->sgl.need_unpin = iov_iter_extract_will_pin(&msg->msg_iter);
136
137 err = extract_iter_to_sg(&msg->msg_iter, LONG_MAX,
138 &ctx->sgl.sgt, npages, 0);
139 if (err < 0)
140 goto unlock_free;
141 len = err;
142 sg_mark_end(ctx->sgl.sgt.sgl + ctx->sgl.sgt.nents - 1);
143
144 if (!msg_data_left(msg)) {
145 err = hash_alloc_result(sk, ctx);
146 if (err)
147 goto unlock_free;
148 }
149
150 ahash_request_set_crypt(&ctx->req, ctx->sgl.sgt.sgl,
151 ctx->result, len);
152
153 if (!msg_data_left(msg) && !continuing &&
154 !(msg->msg_flags & MSG_MORE)) {
155 err = crypto_ahash_digest(&ctx->req);
156 } else {
157 if (need_init) {
158 err = crypto_wait_req(
159 crypto_ahash_init(&ctx->req),
160 &ctx->wait);
161 if (err)
162 goto unlock_free;
163 need_init = false;
164 }
165
166 if (msg_data_left(msg) || (msg->msg_flags & MSG_MORE))
167 err = crypto_ahash_update(&ctx->req);
168 else
169 err = crypto_ahash_finup(&ctx->req);
170 continuing = true;
171 }
172
173 err = crypto_wait_req(err, &ctx->wait);
174 if (err)
175 goto unlock_free;
176
177 copied += len;
178 af_alg_free_sg(&ctx->sgl);
179 }
180
181done_more:
182 ctx->more = msg->msg_flags & MSG_MORE;
183done:
184 err = 0;
185unlock:
186 release_sock(sk);
187 return copied ?: err;
188
189unlock_free:
190 af_alg_free_sg(&ctx->sgl);
191unlock_free_result:
192 hash_free_result(sk, ctx);
193 ctx->more = false;
194 goto unlock;
195}
196
197static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
198 int flags)
199{
200 struct sock *sk = sock->sk;
201 struct alg_sock *ask = alg_sk(sk);
202 struct hash_ctx *ctx = ask->private;
203 unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
204 bool result;
205 int err;
206
207 if (len > ds)
208 len = ds;
209 else if (len < ds)
210 msg->msg_flags |= MSG_TRUNC;
211
212 lock_sock(sk);
213 result = ctx->result;
214 err = hash_alloc_result(sk, ctx);
215 if (err)
216 goto unlock;
217
218 ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0);
219
220 if (!result && !ctx->more) {
221 err = crypto_wait_req(crypto_ahash_init(&ctx->req),
222 &ctx->wait);
223 if (err)
224 goto unlock;
225 }
226
227 if (!result || ctx->more) {
228 ctx->more = false;
229 err = crypto_wait_req(crypto_ahash_final(&ctx->req),
230 &ctx->wait);
231 if (err)
232 goto unlock;
233 }
234
235 err = memcpy_to_msg(msg, ctx->result, len);
236
237unlock:
238 hash_free_result(sk, ctx);
239 release_sock(sk);
240
241 return err ?: len;
242}
243
244static int hash_accept(struct socket *sock, struct socket *newsock,
245 struct proto_accept_arg *arg)
246{
247 struct sock *sk = sock->sk;
248 struct alg_sock *ask = alg_sk(sk);
249 struct hash_ctx *ctx = ask->private;
250 struct ahash_request *req = &ctx->req;
251 struct crypto_ahash *tfm;
252 struct sock *sk2;
253 struct alg_sock *ask2;
254 struct hash_ctx *ctx2;
255 char *state;
256 bool more;
257 int err;
258
259 tfm = crypto_ahash_reqtfm(req);
260 state = kmalloc(crypto_ahash_statesize(tfm), GFP_KERNEL);
261 err = -ENOMEM;
262 if (!state)
263 goto out;
264
265 lock_sock(sk);
266 more = ctx->more;
267 err = more ? crypto_ahash_export(req, state) : 0;
268 release_sock(sk);
269
270 if (err)
271 goto out_free_state;
272
273 err = af_alg_accept(ask->parent, newsock, arg);
274 if (err)
275 goto out_free_state;
276
277 sk2 = newsock->sk;
278 ask2 = alg_sk(sk2);
279 ctx2 = ask2->private;
280 ctx2->more = more;
281
282 if (!more)
283 goto out_free_state;
284
285 err = crypto_ahash_import(&ctx2->req, state);
286
287out_free_state:
288 kfree_sensitive(state);
289
290out:
291 return err;
292}
293
294static struct proto_ops algif_hash_ops = {
295 .family = PF_ALG,
296
297 .connect = sock_no_connect,
298 .socketpair = sock_no_socketpair,
299 .getname = sock_no_getname,
300 .ioctl = sock_no_ioctl,
301 .listen = sock_no_listen,
302 .shutdown = sock_no_shutdown,
303 .mmap = sock_no_mmap,
304 .bind = sock_no_bind,
305
306 .release = af_alg_release,
307 .sendmsg = hash_sendmsg,
308 .recvmsg = hash_recvmsg,
309 .accept = hash_accept,
310};
311
312static int hash_check_key(struct socket *sock)
313{
314 int err = 0;
315 struct sock *psk;
316 struct alg_sock *pask;
317 struct crypto_ahash *tfm;
318 struct sock *sk = sock->sk;
319 struct alg_sock *ask = alg_sk(sk);
320
321 lock_sock(sk);
322 if (!atomic_read(&ask->nokey_refcnt))
323 goto unlock_child;
324
325 psk = ask->parent;
326 pask = alg_sk(ask->parent);
327 tfm = pask->private;
328
329 err = -ENOKEY;
330 lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
331 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
332 goto unlock;
333
334 atomic_dec(&pask->nokey_refcnt);
335 atomic_set(&ask->nokey_refcnt, 0);
336
337 err = 0;
338
339unlock:
340 release_sock(psk);
341unlock_child:
342 release_sock(sk);
343
344 return err;
345}
346
347static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
348 size_t size)
349{
350 int err;
351
352 err = hash_check_key(sock);
353 if (err)
354 return err;
355
356 return hash_sendmsg(sock, msg, size);
357}
358
359static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
360 size_t ignored, int flags)
361{
362 int err;
363
364 err = hash_check_key(sock);
365 if (err)
366 return err;
367
368 return hash_recvmsg(sock, msg, ignored, flags);
369}
370
371static int hash_accept_nokey(struct socket *sock, struct socket *newsock,
372 struct proto_accept_arg *arg)
373{
374 int err;
375
376 err = hash_check_key(sock);
377 if (err)
378 return err;
379
380 return hash_accept(sock, newsock, arg);
381}
382
383static struct proto_ops algif_hash_ops_nokey = {
384 .family = PF_ALG,
385
386 .connect = sock_no_connect,
387 .socketpair = sock_no_socketpair,
388 .getname = sock_no_getname,
389 .ioctl = sock_no_ioctl,
390 .listen = sock_no_listen,
391 .shutdown = sock_no_shutdown,
392 .mmap = sock_no_mmap,
393 .bind = sock_no_bind,
394
395 .release = af_alg_release,
396 .sendmsg = hash_sendmsg_nokey,
397 .recvmsg = hash_recvmsg_nokey,
398 .accept = hash_accept_nokey,
399};
400
401static void *hash_bind(const char *name)
402{
403 int err;
404
405 err = af_alg_check_restriction(name, hash_allowlist);
406 if (err)
407 return ERR_PTR(err);
408
409 return crypto_alloc_ahash(name, 0, AF_ALG_CRYPTOAPI_MASK);
410}
411
412static void hash_release(void *private)
413{
414 crypto_free_ahash(private);
415}
416
417static int hash_setkey(void *private, const u8 *key, unsigned int keylen)
418{
419 return crypto_ahash_setkey(private, key, keylen);
420}
421
422static void hash_sock_destruct(struct sock *sk)
423{
424 struct alg_sock *ask = alg_sk(sk);
425 struct hash_ctx *ctx = ask->private;
426
427 hash_free_result(sk, ctx);
428 sock_kfree_s(sk, ctx, ctx->len);
429 af_alg_release_parent(sk);
430}
431
432static int hash_accept_parent_nokey(void *private, struct sock *sk)
433{
434 struct crypto_ahash *tfm = private;
435 struct alg_sock *ask = alg_sk(sk);
436 struct hash_ctx *ctx;
437 unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm);
438
439 ctx = sock_kmalloc(sk, len, GFP_KERNEL);
440 if (!ctx)
441 return -ENOMEM;
442
443 memset(ctx, 0, len);
444 ctx->len = len;
445 crypto_init_wait(&ctx->wait);
446
447 ask->private = ctx;
448
449 ahash_request_set_tfm(&ctx->req, tfm);
450 ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
451 crypto_req_done, &ctx->wait);
452
453 sk->sk_destruct = hash_sock_destruct;
454
455 return 0;
456}
457
458static int hash_accept_parent(void *private, struct sock *sk)
459{
460 struct crypto_ahash *tfm = private;
461
462 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
463 return -ENOKEY;
464
465 return hash_accept_parent_nokey(private, sk);
466}
467
468static const struct af_alg_type algif_type_hash = {
469 .bind = hash_bind,
470 .release = hash_release,
471 .setkey = hash_setkey,
472 .accept = hash_accept_parent,
473 .accept_nokey = hash_accept_parent_nokey,
474 .ops = &algif_hash_ops,
475 .ops_nokey = &algif_hash_ops_nokey,
476 .name = "hash",
477 .owner = THIS_MODULE
478};
479
480static int __init algif_hash_init(void)
481{
482 return af_alg_register_type(&algif_type_hash);
483}
484
485static void __exit algif_hash_exit(void)
486{
487 int err = af_alg_unregister_type(&algif_type_hash);
488 BUG_ON(err);
489}
490
491module_init(algif_hash_init);
492module_exit(algif_hash_exit);
493MODULE_DESCRIPTION("Userspace interface for hash algorithms");
494MODULE_LICENSE("GPL");