Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
fe869cdb HX |
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 <herbert@gondor.apana.org.au> | |
fe869cdb HX |
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 | ||
19 | struct hash_ctx { | |
20 | struct af_alg_sgl sgl; | |
21 | ||
22 | u8 *result; | |
23 | ||
2c3f8b16 | 24 | struct crypto_wait wait; |
fe869cdb HX |
25 | |
26 | unsigned int len; | |
27 | bool more; | |
28 | ||
29 | struct ahash_request req; | |
30 | }; | |
31 | ||
493b2ed3 HX |
32 | static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx) |
33 | { | |
34 | unsigned ds; | |
35 | ||
36 | if (ctx->result) | |
37 | return 0; | |
38 | ||
39 | ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); | |
40 | ||
41 | ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL); | |
42 | if (!ctx->result) | |
43 | return -ENOMEM; | |
44 | ||
45 | memset(ctx->result, 0, ds); | |
46 | ||
47 | return 0; | |
48 | } | |
49 | ||
50 | static void hash_free_result(struct sock *sk, struct hash_ctx *ctx) | |
51 | { | |
52 | unsigned ds; | |
53 | ||
54 | if (!ctx->result) | |
55 | return; | |
56 | ||
57 | ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); | |
58 | ||
59 | sock_kzfree_s(sk, ctx->result, ds); | |
60 | ctx->result = NULL; | |
61 | } | |
62 | ||
1b784140 YX |
63 | static int hash_sendmsg(struct socket *sock, struct msghdr *msg, |
64 | size_t ignored) | |
fe869cdb HX |
65 | { |
66 | int limit = ALG_MAX_PAGES * PAGE_SIZE; | |
67 | struct sock *sk = sock->sk; | |
68 | struct alg_sock *ask = alg_sk(sk); | |
69 | struct hash_ctx *ctx = ask->private; | |
fe869cdb HX |
70 | long copied = 0; |
71 | int err; | |
72 | ||
73 | if (limit > sk->sk_sndbuf) | |
74 | limit = sk->sk_sndbuf; | |
75 | ||
76 | lock_sock(sk); | |
77 | if (!ctx->more) { | |
493b2ed3 HX |
78 | if ((msg->msg_flags & MSG_MORE)) |
79 | hash_free_result(sk, ctx); | |
80 | ||
2c3f8b16 | 81 | err = crypto_wait_req(crypto_ahash_init(&ctx->req), &ctx->wait); |
fe869cdb HX |
82 | if (err) |
83 | goto unlock; | |
84 | } | |
85 | ||
fcb90d51 | 86 | ctx->more = false; |
fe869cdb | 87 | |
01e97e65 AV |
88 | while (msg_data_left(msg)) { |
89 | int len = msg_data_left(msg); | |
fe869cdb | 90 | |
1d10eb2f AV |
91 | if (len > limit) |
92 | len = limit; | |
fe869cdb | 93 | |
1d10eb2f AV |
94 | len = af_alg_make_sg(&ctx->sgl, &msg->msg_iter, len); |
95 | if (len < 0) { | |
96 | err = copied ? 0 : len; | |
97 | goto unlock; | |
98 | } | |
fe869cdb | 99 | |
1d10eb2f | 100 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, NULL, len); |
fe869cdb | 101 | |
2c3f8b16 GBY |
102 | err = crypto_wait_req(crypto_ahash_update(&ctx->req), |
103 | &ctx->wait); | |
1d10eb2f | 104 | af_alg_free_sg(&ctx->sgl); |
dc5801f6 AV |
105 | if (err) { |
106 | iov_iter_revert(&msg->msg_iter, len); | |
1d10eb2f | 107 | goto unlock; |
dc5801f6 | 108 | } |
fe869cdb | 109 | |
1d10eb2f | 110 | copied += len; |
fe869cdb HX |
111 | } |
112 | ||
113 | err = 0; | |
114 | ||
115 | ctx->more = msg->msg_flags & MSG_MORE; | |
116 | if (!ctx->more) { | |
493b2ed3 HX |
117 | err = hash_alloc_result(sk, ctx); |
118 | if (err) | |
119 | goto unlock; | |
120 | ||
fe869cdb | 121 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); |
2c3f8b16 GBY |
122 | err = crypto_wait_req(crypto_ahash_final(&ctx->req), |
123 | &ctx->wait); | |
fe869cdb HX |
124 | } |
125 | ||
126 | unlock: | |
127 | release_sock(sk); | |
128 | ||
129 | return err ?: copied; | |
130 | } | |
131 | ||
132 | static ssize_t hash_sendpage(struct socket *sock, struct page *page, | |
133 | int offset, size_t size, int flags) | |
134 | { | |
135 | struct sock *sk = sock->sk; | |
136 | struct alg_sock *ask = alg_sk(sk); | |
137 | struct hash_ctx *ctx = ask->private; | |
138 | int err; | |
139 | ||
d3f7d56a SL |
140 | if (flags & MSG_SENDPAGE_NOTLAST) |
141 | flags |= MSG_MORE; | |
142 | ||
fe869cdb HX |
143 | lock_sock(sk); |
144 | sg_init_table(ctx->sgl.sg, 1); | |
145 | sg_set_page(ctx->sgl.sg, page, size, offset); | |
146 | ||
493b2ed3 HX |
147 | if (!(flags & MSG_MORE)) { |
148 | err = hash_alloc_result(sk, ctx); | |
149 | if (err) | |
150 | goto unlock; | |
151 | } else if (!ctx->more) | |
152 | hash_free_result(sk, ctx); | |
153 | ||
fe869cdb HX |
154 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, ctx->result, size); |
155 | ||
156 | if (!(flags & MSG_MORE)) { | |
157 | if (ctx->more) | |
158 | err = crypto_ahash_finup(&ctx->req); | |
159 | else | |
160 | err = crypto_ahash_digest(&ctx->req); | |
161 | } else { | |
162 | if (!ctx->more) { | |
163 | err = crypto_ahash_init(&ctx->req); | |
2c3f8b16 | 164 | err = crypto_wait_req(err, &ctx->wait); |
fe869cdb HX |
165 | if (err) |
166 | goto unlock; | |
167 | } | |
168 | ||
169 | err = crypto_ahash_update(&ctx->req); | |
170 | } | |
171 | ||
2c3f8b16 | 172 | err = crypto_wait_req(err, &ctx->wait); |
fe869cdb HX |
173 | if (err) |
174 | goto unlock; | |
175 | ||
176 | ctx->more = flags & MSG_MORE; | |
177 | ||
178 | unlock: | |
179 | release_sock(sk); | |
180 | ||
181 | return err ?: size; | |
182 | } | |
183 | ||
1b784140 YX |
184 | static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, |
185 | int flags) | |
fe869cdb HX |
186 | { |
187 | struct sock *sk = sock->sk; | |
188 | struct alg_sock *ask = alg_sk(sk); | |
189 | struct hash_ctx *ctx = ask->private; | |
190 | unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); | |
493b2ed3 | 191 | bool result; |
fe869cdb HX |
192 | int err; |
193 | ||
194 | if (len > ds) | |
195 | len = ds; | |
196 | else if (len < ds) | |
197 | msg->msg_flags |= MSG_TRUNC; | |
198 | ||
199 | lock_sock(sk); | |
493b2ed3 HX |
200 | result = ctx->result; |
201 | err = hash_alloc_result(sk, ctx); | |
202 | if (err) | |
203 | goto unlock; | |
204 | ||
205 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); | |
206 | ||
8acf7a10 | 207 | if (!result && !ctx->more) { |
2c3f8b16 GBY |
208 | err = crypto_wait_req(crypto_ahash_init(&ctx->req), |
209 | &ctx->wait); | |
a8348bca HX |
210 | if (err) |
211 | goto unlock; | |
212 | } | |
213 | ||
214 | if (!result || ctx->more) { | |
fcb90d51 | 215 | ctx->more = false; |
2c3f8b16 GBY |
216 | err = crypto_wait_req(crypto_ahash_final(&ctx->req), |
217 | &ctx->wait); | |
fe869cdb HX |
218 | if (err) |
219 | goto unlock; | |
220 | } | |
221 | ||
7eab8d9e | 222 | err = memcpy_to_msg(msg, ctx->result, len); |
fe869cdb HX |
223 | |
224 | unlock: | |
a8348bca | 225 | hash_free_result(sk, ctx); |
fe869cdb HX |
226 | release_sock(sk); |
227 | ||
228 | return err ?: len; | |
229 | } | |
230 | ||
cdfbabfb DH |
231 | static int hash_accept(struct socket *sock, struct socket *newsock, int flags, |
232 | bool kern) | |
fe869cdb HX |
233 | { |
234 | struct sock *sk = sock->sk; | |
235 | struct alg_sock *ask = alg_sk(sk); | |
236 | struct hash_ctx *ctx = ask->private; | |
237 | struct ahash_request *req = &ctx->req; | |
acc03d89 | 238 | struct crypto_ahash *tfm; |
fe869cdb HX |
239 | struct sock *sk2; |
240 | struct alg_sock *ask2; | |
241 | struct hash_ctx *ctx2; | |
acc03d89 | 242 | char *state; |
4afa5f96 | 243 | bool more; |
fe869cdb HX |
244 | int err; |
245 | ||
acc03d89 HX |
246 | tfm = crypto_ahash_reqtfm(req); |
247 | state = kmalloc(crypto_ahash_statesize(tfm), GFP_KERNEL); | |
248 | err = -ENOMEM; | |
249 | if (!state) | |
250 | goto out; | |
251 | ||
4afa5f96 HX |
252 | lock_sock(sk); |
253 | more = ctx->more; | |
254 | err = more ? crypto_ahash_export(req, state) : 0; | |
255 | release_sock(sk); | |
256 | ||
fe869cdb | 257 | if (err) |
acc03d89 | 258 | goto out_free_state; |
fe869cdb | 259 | |
cdfbabfb | 260 | err = af_alg_accept(ask->parent, newsock, kern); |
fe869cdb | 261 | if (err) |
acc03d89 | 262 | goto out_free_state; |
fe869cdb HX |
263 | |
264 | sk2 = newsock->sk; | |
265 | ask2 = alg_sk(sk2); | |
266 | ctx2 = ask2->private; | |
4afa5f96 HX |
267 | ctx2->more = more; |
268 | ||
269 | if (!more) | |
acc03d89 | 270 | goto out_free_state; |
fe869cdb HX |
271 | |
272 | err = crypto_ahash_import(&ctx2->req, state); | |
273 | if (err) { | |
274 | sock_orphan(sk2); | |
275 | sock_put(sk2); | |
276 | } | |
277 | ||
acc03d89 HX |
278 | out_free_state: |
279 | kfree_sensitive(state); | |
280 | ||
281 | out: | |
fe869cdb HX |
282 | return err; |
283 | } | |
284 | ||
285 | static struct proto_ops algif_hash_ops = { | |
286 | .family = PF_ALG, | |
287 | ||
288 | .connect = sock_no_connect, | |
289 | .socketpair = sock_no_socketpair, | |
290 | .getname = sock_no_getname, | |
291 | .ioctl = sock_no_ioctl, | |
292 | .listen = sock_no_listen, | |
293 | .shutdown = sock_no_shutdown, | |
fe869cdb HX |
294 | .mmap = sock_no_mmap, |
295 | .bind = sock_no_bind, | |
fe869cdb HX |
296 | |
297 | .release = af_alg_release, | |
298 | .sendmsg = hash_sendmsg, | |
299 | .sendpage = hash_sendpage, | |
300 | .recvmsg = hash_recvmsg, | |
301 | .accept = hash_accept, | |
302 | }; | |
303 | ||
6de62f15 HX |
304 | static int hash_check_key(struct socket *sock) |
305 | { | |
ad46d7e3 | 306 | int err = 0; |
6de62f15 HX |
307 | struct sock *psk; |
308 | struct alg_sock *pask; | |
9fa68f62 | 309 | struct crypto_ahash *tfm; |
6de62f15 HX |
310 | struct sock *sk = sock->sk; |
311 | struct alg_sock *ask = alg_sk(sk); | |
312 | ||
ad46d7e3 | 313 | lock_sock(sk); |
34c86f4c | 314 | if (!atomic_read(&ask->nokey_refcnt)) |
ad46d7e3 | 315 | goto unlock_child; |
6de62f15 HX |
316 | |
317 | psk = ask->parent; | |
318 | pask = alg_sk(ask->parent); | |
319 | tfm = pask->private; | |
320 | ||
321 | err = -ENOKEY; | |
ad46d7e3 | 322 | lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
9fa68f62 | 323 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
6de62f15 HX |
324 | goto unlock; |
325 | ||
34c86f4c HX |
326 | atomic_dec(&pask->nokey_refcnt); |
327 | atomic_set(&ask->nokey_refcnt, 0); | |
6de62f15 HX |
328 | |
329 | err = 0; | |
330 | ||
331 | unlock: | |
332 | release_sock(psk); | |
ad46d7e3 HX |
333 | unlock_child: |
334 | release_sock(sk); | |
6de62f15 HX |
335 | |
336 | return err; | |
337 | } | |
338 | ||
339 | static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | |
340 | size_t size) | |
341 | { | |
342 | int err; | |
343 | ||
344 | err = hash_check_key(sock); | |
345 | if (err) | |
346 | return err; | |
347 | ||
348 | return hash_sendmsg(sock, msg, size); | |
349 | } | |
350 | ||
351 | static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, | |
352 | int offset, size_t size, int flags) | |
353 | { | |
354 | int err; | |
355 | ||
356 | err = hash_check_key(sock); | |
357 | if (err) | |
358 | return err; | |
359 | ||
360 | return hash_sendpage(sock, page, offset, size, flags); | |
361 | } | |
362 | ||
363 | static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | |
364 | size_t ignored, int flags) | |
365 | { | |
366 | int err; | |
367 | ||
368 | err = hash_check_key(sock); | |
369 | if (err) | |
370 | return err; | |
371 | ||
372 | return hash_recvmsg(sock, msg, ignored, flags); | |
373 | } | |
374 | ||
375 | static int hash_accept_nokey(struct socket *sock, struct socket *newsock, | |
cdfbabfb | 376 | int flags, bool kern) |
6de62f15 HX |
377 | { |
378 | int err; | |
379 | ||
380 | err = hash_check_key(sock); | |
381 | if (err) | |
382 | return err; | |
383 | ||
cdfbabfb | 384 | return hash_accept(sock, newsock, flags, kern); |
6de62f15 HX |
385 | } |
386 | ||
387 | static struct proto_ops algif_hash_ops_nokey = { | |
388 | .family = PF_ALG, | |
389 | ||
390 | .connect = sock_no_connect, | |
391 | .socketpair = sock_no_socketpair, | |
392 | .getname = sock_no_getname, | |
393 | .ioctl = sock_no_ioctl, | |
394 | .listen = sock_no_listen, | |
395 | .shutdown = sock_no_shutdown, | |
6de62f15 HX |
396 | .mmap = sock_no_mmap, |
397 | .bind = sock_no_bind, | |
6de62f15 HX |
398 | |
399 | .release = af_alg_release, | |
400 | .sendmsg = hash_sendmsg_nokey, | |
401 | .sendpage = hash_sendpage_nokey, | |
402 | .recvmsg = hash_recvmsg_nokey, | |
403 | .accept = hash_accept_nokey, | |
404 | }; | |
405 | ||
fe869cdb HX |
406 | static void *hash_bind(const char *name, u32 type, u32 mask) |
407 | { | |
9fa68f62 | 408 | return crypto_alloc_ahash(name, type, mask); |
fe869cdb HX |
409 | } |
410 | ||
411 | static void hash_release(void *private) | |
412 | { | |
9fa68f62 | 413 | crypto_free_ahash(private); |
fe869cdb HX |
414 | } |
415 | ||
416 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) | |
417 | { | |
9fa68f62 | 418 | return crypto_ahash_setkey(private, key, keylen); |
fe869cdb HX |
419 | } |
420 | ||
f1d84af1 | 421 | static void hash_sock_destruct(struct sock *sk) |
fe869cdb HX |
422 | { |
423 | struct alg_sock *ask = alg_sk(sk); | |
424 | struct hash_ctx *ctx = ask->private; | |
425 | ||
493b2ed3 | 426 | hash_free_result(sk, ctx); |
fe869cdb | 427 | sock_kfree_s(sk, ctx, ctx->len); |
6de62f15 HX |
428 | af_alg_release_parent(sk); |
429 | } | |
430 | ||
f1d84af1 | 431 | static int hash_accept_parent_nokey(void *private, struct sock *sk) |
fe869cdb | 432 | { |
9fa68f62 | 433 | struct crypto_ahash *tfm = private; |
fe869cdb | 434 | struct alg_sock *ask = alg_sk(sk); |
9fa68f62 EB |
435 | struct hash_ctx *ctx; |
436 | unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm); | |
fe869cdb HX |
437 | |
438 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | |
439 | if (!ctx) | |
440 | return -ENOMEM; | |
441 | ||
493b2ed3 | 442 | ctx->result = NULL; |
fe869cdb | 443 | ctx->len = len; |
fcb90d51 | 444 | ctx->more = false; |
2c3f8b16 | 445 | crypto_init_wait(&ctx->wait); |
fe869cdb HX |
446 | |
447 | ask->private = ctx; | |
448 | ||
9fa68f62 | 449 | ahash_request_set_tfm(&ctx->req, tfm); |
fe869cdb | 450 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
2c3f8b16 | 451 | crypto_req_done, &ctx->wait); |
fe869cdb HX |
452 | |
453 | sk->sk_destruct = hash_sock_destruct; | |
454 | ||
455 | return 0; | |
456 | } | |
457 | ||
6de62f15 HX |
458 | static int hash_accept_parent(void *private, struct sock *sk) |
459 | { | |
9fa68f62 | 460 | struct crypto_ahash *tfm = private; |
6de62f15 | 461 | |
9fa68f62 | 462 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
6de62f15 HX |
463 | return -ENOKEY; |
464 | ||
f1d84af1 | 465 | return hash_accept_parent_nokey(private, sk); |
6de62f15 HX |
466 | } |
467 | ||
fe869cdb HX |
468 | static 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, | |
6de62f15 | 473 | .accept_nokey = hash_accept_parent_nokey, |
fe869cdb | 474 | .ops = &algif_hash_ops, |
6de62f15 | 475 | .ops_nokey = &algif_hash_ops_nokey, |
fe869cdb HX |
476 | .name = "hash", |
477 | .owner = THIS_MODULE | |
478 | }; | |
479 | ||
480 | static int __init algif_hash_init(void) | |
481 | { | |
482 | return af_alg_register_type(&algif_type_hash); | |
483 | } | |
484 | ||
485 | static void __exit algif_hash_exit(void) | |
486 | { | |
487 | int err = af_alg_unregister_type(&algif_type_hash); | |
488 | BUG_ON(err); | |
489 | } | |
490 | ||
491 | module_init(algif_hash_init); | |
492 | module_exit(algif_hash_exit); | |
493 | MODULE_LICENSE("GPL"); |