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