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; | |
b68a7ec1 | 238 | char state[HASH_MAX_STATESIZE]; |
fe869cdb HX |
239 | struct sock *sk2; |
240 | struct alg_sock *ask2; | |
241 | struct hash_ctx *ctx2; | |
4afa5f96 | 242 | bool more; |
fe869cdb HX |
243 | int err; |
244 | ||
4afa5f96 HX |
245 | lock_sock(sk); |
246 | more = ctx->more; | |
247 | err = more ? crypto_ahash_export(req, state) : 0; | |
248 | release_sock(sk); | |
249 | ||
fe869cdb HX |
250 | if (err) |
251 | return err; | |
252 | ||
cdfbabfb | 253 | err = af_alg_accept(ask->parent, newsock, kern); |
fe869cdb HX |
254 | if (err) |
255 | return err; | |
256 | ||
257 | sk2 = newsock->sk; | |
258 | ask2 = alg_sk(sk2); | |
259 | ctx2 = ask2->private; | |
4afa5f96 HX |
260 | ctx2->more = more; |
261 | ||
262 | if (!more) | |
263 | return err; | |
fe869cdb HX |
264 | |
265 | err = crypto_ahash_import(&ctx2->req, state); | |
266 | if (err) { | |
267 | sock_orphan(sk2); | |
268 | sock_put(sk2); | |
269 | } | |
270 | ||
271 | return err; | |
272 | } | |
273 | ||
274 | static struct proto_ops algif_hash_ops = { | |
275 | .family = PF_ALG, | |
276 | ||
277 | .connect = sock_no_connect, | |
278 | .socketpair = sock_no_socketpair, | |
279 | .getname = sock_no_getname, | |
280 | .ioctl = sock_no_ioctl, | |
281 | .listen = sock_no_listen, | |
282 | .shutdown = sock_no_shutdown, | |
fe869cdb HX |
283 | .mmap = sock_no_mmap, |
284 | .bind = sock_no_bind, | |
fe869cdb HX |
285 | |
286 | .release = af_alg_release, | |
287 | .sendmsg = hash_sendmsg, | |
288 | .sendpage = hash_sendpage, | |
289 | .recvmsg = hash_recvmsg, | |
290 | .accept = hash_accept, | |
291 | }; | |
292 | ||
6de62f15 HX |
293 | static int hash_check_key(struct socket *sock) |
294 | { | |
ad46d7e3 | 295 | int err = 0; |
6de62f15 HX |
296 | struct sock *psk; |
297 | struct alg_sock *pask; | |
9fa68f62 | 298 | struct crypto_ahash *tfm; |
6de62f15 HX |
299 | struct sock *sk = sock->sk; |
300 | struct alg_sock *ask = alg_sk(sk); | |
301 | ||
ad46d7e3 | 302 | lock_sock(sk); |
34c86f4c | 303 | if (!atomic_read(&ask->nokey_refcnt)) |
ad46d7e3 | 304 | goto unlock_child; |
6de62f15 HX |
305 | |
306 | psk = ask->parent; | |
307 | pask = alg_sk(ask->parent); | |
308 | tfm = pask->private; | |
309 | ||
310 | err = -ENOKEY; | |
ad46d7e3 | 311 | lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
9fa68f62 | 312 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
6de62f15 HX |
313 | goto unlock; |
314 | ||
34c86f4c HX |
315 | atomic_dec(&pask->nokey_refcnt); |
316 | atomic_set(&ask->nokey_refcnt, 0); | |
6de62f15 HX |
317 | |
318 | err = 0; | |
319 | ||
320 | unlock: | |
321 | release_sock(psk); | |
ad46d7e3 HX |
322 | unlock_child: |
323 | release_sock(sk); | |
6de62f15 HX |
324 | |
325 | return err; | |
326 | } | |
327 | ||
328 | static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | |
329 | size_t size) | |
330 | { | |
331 | int err; | |
332 | ||
333 | err = hash_check_key(sock); | |
334 | if (err) | |
335 | return err; | |
336 | ||
337 | return hash_sendmsg(sock, msg, size); | |
338 | } | |
339 | ||
340 | static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, | |
341 | int offset, size_t size, int flags) | |
342 | { | |
343 | int err; | |
344 | ||
345 | err = hash_check_key(sock); | |
346 | if (err) | |
347 | return err; | |
348 | ||
349 | return hash_sendpage(sock, page, offset, size, flags); | |
350 | } | |
351 | ||
352 | static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | |
353 | size_t ignored, int flags) | |
354 | { | |
355 | int err; | |
356 | ||
357 | err = hash_check_key(sock); | |
358 | if (err) | |
359 | return err; | |
360 | ||
361 | return hash_recvmsg(sock, msg, ignored, flags); | |
362 | } | |
363 | ||
364 | static int hash_accept_nokey(struct socket *sock, struct socket *newsock, | |
cdfbabfb | 365 | int flags, bool kern) |
6de62f15 HX |
366 | { |
367 | int err; | |
368 | ||
369 | err = hash_check_key(sock); | |
370 | if (err) | |
371 | return err; | |
372 | ||
cdfbabfb | 373 | return hash_accept(sock, newsock, flags, kern); |
6de62f15 HX |
374 | } |
375 | ||
376 | static struct proto_ops algif_hash_ops_nokey = { | |
377 | .family = PF_ALG, | |
378 | ||
379 | .connect = sock_no_connect, | |
380 | .socketpair = sock_no_socketpair, | |
381 | .getname = sock_no_getname, | |
382 | .ioctl = sock_no_ioctl, | |
383 | .listen = sock_no_listen, | |
384 | .shutdown = sock_no_shutdown, | |
6de62f15 HX |
385 | .mmap = sock_no_mmap, |
386 | .bind = sock_no_bind, | |
6de62f15 HX |
387 | |
388 | .release = af_alg_release, | |
389 | .sendmsg = hash_sendmsg_nokey, | |
390 | .sendpage = hash_sendpage_nokey, | |
391 | .recvmsg = hash_recvmsg_nokey, | |
392 | .accept = hash_accept_nokey, | |
393 | }; | |
394 | ||
fe869cdb HX |
395 | static void *hash_bind(const char *name, u32 type, u32 mask) |
396 | { | |
9fa68f62 | 397 | return crypto_alloc_ahash(name, type, mask); |
fe869cdb HX |
398 | } |
399 | ||
400 | static void hash_release(void *private) | |
401 | { | |
9fa68f62 | 402 | crypto_free_ahash(private); |
fe869cdb HX |
403 | } |
404 | ||
405 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) | |
406 | { | |
9fa68f62 | 407 | return crypto_ahash_setkey(private, key, keylen); |
fe869cdb HX |
408 | } |
409 | ||
f1d84af1 | 410 | static void hash_sock_destruct(struct sock *sk) |
fe869cdb HX |
411 | { |
412 | struct alg_sock *ask = alg_sk(sk); | |
413 | struct hash_ctx *ctx = ask->private; | |
414 | ||
493b2ed3 | 415 | hash_free_result(sk, ctx); |
fe869cdb | 416 | sock_kfree_s(sk, ctx, ctx->len); |
6de62f15 HX |
417 | af_alg_release_parent(sk); |
418 | } | |
419 | ||
f1d84af1 | 420 | static int hash_accept_parent_nokey(void *private, struct sock *sk) |
fe869cdb | 421 | { |
9fa68f62 | 422 | struct crypto_ahash *tfm = private; |
fe869cdb | 423 | struct alg_sock *ask = alg_sk(sk); |
9fa68f62 EB |
424 | struct hash_ctx *ctx; |
425 | unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm); | |
fe869cdb HX |
426 | |
427 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | |
428 | if (!ctx) | |
429 | return -ENOMEM; | |
430 | ||
493b2ed3 | 431 | ctx->result = NULL; |
fe869cdb | 432 | ctx->len = len; |
fcb90d51 | 433 | ctx->more = false; |
2c3f8b16 | 434 | crypto_init_wait(&ctx->wait); |
fe869cdb HX |
435 | |
436 | ask->private = ctx; | |
437 | ||
9fa68f62 | 438 | ahash_request_set_tfm(&ctx->req, tfm); |
fe869cdb | 439 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
2c3f8b16 | 440 | crypto_req_done, &ctx->wait); |
fe869cdb HX |
441 | |
442 | sk->sk_destruct = hash_sock_destruct; | |
443 | ||
444 | return 0; | |
445 | } | |
446 | ||
6de62f15 HX |
447 | static int hash_accept_parent(void *private, struct sock *sk) |
448 | { | |
9fa68f62 | 449 | struct crypto_ahash *tfm = private; |
6de62f15 | 450 | |
9fa68f62 | 451 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
6de62f15 HX |
452 | return -ENOKEY; |
453 | ||
f1d84af1 | 454 | return hash_accept_parent_nokey(private, sk); |
6de62f15 HX |
455 | } |
456 | ||
fe869cdb HX |
457 | static const struct af_alg_type algif_type_hash = { |
458 | .bind = hash_bind, | |
459 | .release = hash_release, | |
460 | .setkey = hash_setkey, | |
461 | .accept = hash_accept_parent, | |
6de62f15 | 462 | .accept_nokey = hash_accept_parent_nokey, |
fe869cdb | 463 | .ops = &algif_hash_ops, |
6de62f15 | 464 | .ops_nokey = &algif_hash_ops_nokey, |
fe869cdb HX |
465 | .name = "hash", |
466 | .owner = THIS_MODULE | |
467 | }; | |
468 | ||
469 | static int __init algif_hash_init(void) | |
470 | { | |
471 | return af_alg_register_type(&algif_type_hash); | |
472 | } | |
473 | ||
474 | static void __exit algif_hash_exit(void) | |
475 | { | |
476 | int err = af_alg_unregister_type(&algif_type_hash); | |
477 | BUG_ON(err); | |
478 | } | |
479 | ||
480 | module_init(algif_hash_init); | |
481 | module_exit(algif_hash_exit); | |
482 | MODULE_LICENSE("GPL"); |