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 | ||
29 | struct af_alg_completion completion; | |
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 | ||
fe097861 WR |
91 | err = af_alg_wait_for_completion(crypto_ahash_init(&ctx->req), |
92 | &ctx->completion); | |
fe869cdb HX |
93 | if (err) |
94 | goto unlock; | |
95 | } | |
96 | ||
97 | ctx->more = 0; | |
98 | ||
01e97e65 AV |
99 | while (msg_data_left(msg)) { |
100 | int len = msg_data_left(msg); | |
fe869cdb | 101 | |
1d10eb2f AV |
102 | if (len > limit) |
103 | len = limit; | |
fe869cdb | 104 | |
1d10eb2f AV |
105 | len = af_alg_make_sg(&ctx->sgl, &msg->msg_iter, len); |
106 | if (len < 0) { | |
107 | err = copied ? 0 : len; | |
108 | goto unlock; | |
109 | } | |
fe869cdb | 110 | |
1d10eb2f | 111 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, NULL, len); |
fe869cdb | 112 | |
1d10eb2f AV |
113 | err = af_alg_wait_for_completion(crypto_ahash_update(&ctx->req), |
114 | &ctx->completion); | |
115 | af_alg_free_sg(&ctx->sgl); | |
116 | if (err) | |
117 | goto unlock; | |
fe869cdb | 118 | |
1d10eb2f AV |
119 | copied += len; |
120 | iov_iter_advance(&msg->msg_iter, len); | |
fe869cdb HX |
121 | } |
122 | ||
123 | err = 0; | |
124 | ||
125 | ctx->more = msg->msg_flags & MSG_MORE; | |
126 | if (!ctx->more) { | |
493b2ed3 HX |
127 | err = hash_alloc_result(sk, ctx); |
128 | if (err) | |
129 | goto unlock; | |
130 | ||
fe869cdb HX |
131 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); |
132 | err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), | |
133 | &ctx->completion); | |
134 | } | |
135 | ||
136 | unlock: | |
137 | release_sock(sk); | |
138 | ||
139 | return err ?: copied; | |
140 | } | |
141 | ||
142 | static ssize_t hash_sendpage(struct socket *sock, struct page *page, | |
143 | int offset, size_t size, int flags) | |
144 | { | |
145 | struct sock *sk = sock->sk; | |
146 | struct alg_sock *ask = alg_sk(sk); | |
147 | struct hash_ctx *ctx = ask->private; | |
148 | int err; | |
149 | ||
d3f7d56a SL |
150 | if (flags & MSG_SENDPAGE_NOTLAST) |
151 | flags |= MSG_MORE; | |
152 | ||
fe869cdb HX |
153 | lock_sock(sk); |
154 | sg_init_table(ctx->sgl.sg, 1); | |
155 | sg_set_page(ctx->sgl.sg, page, size, offset); | |
156 | ||
493b2ed3 HX |
157 | if (!(flags & MSG_MORE)) { |
158 | err = hash_alloc_result(sk, ctx); | |
159 | if (err) | |
160 | goto unlock; | |
161 | } else if (!ctx->more) | |
162 | hash_free_result(sk, ctx); | |
163 | ||
fe869cdb HX |
164 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, ctx->result, size); |
165 | ||
166 | if (!(flags & MSG_MORE)) { | |
167 | if (ctx->more) | |
168 | err = crypto_ahash_finup(&ctx->req); | |
169 | else | |
170 | err = crypto_ahash_digest(&ctx->req); | |
171 | } else { | |
172 | if (!ctx->more) { | |
173 | err = crypto_ahash_init(&ctx->req); | |
fe097861 | 174 | err = af_alg_wait_for_completion(err, &ctx->completion); |
fe869cdb HX |
175 | if (err) |
176 | goto unlock; | |
177 | } | |
178 | ||
179 | err = crypto_ahash_update(&ctx->req); | |
180 | } | |
181 | ||
182 | err = af_alg_wait_for_completion(err, &ctx->completion); | |
183 | if (err) | |
184 | goto unlock; | |
185 | ||
186 | ctx->more = flags & MSG_MORE; | |
187 | ||
188 | unlock: | |
189 | release_sock(sk); | |
190 | ||
191 | return err ?: size; | |
192 | } | |
193 | ||
1b784140 YX |
194 | static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, |
195 | int flags) | |
fe869cdb HX |
196 | { |
197 | struct sock *sk = sock->sk; | |
198 | struct alg_sock *ask = alg_sk(sk); | |
199 | struct hash_ctx *ctx = ask->private; | |
200 | unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); | |
493b2ed3 | 201 | bool result; |
fe869cdb HX |
202 | int err; |
203 | ||
204 | if (len > ds) | |
205 | len = ds; | |
206 | else if (len < ds) | |
207 | msg->msg_flags |= MSG_TRUNC; | |
208 | ||
209 | lock_sock(sk); | |
493b2ed3 HX |
210 | result = ctx->result; |
211 | err = hash_alloc_result(sk, ctx); | |
212 | if (err) | |
213 | goto unlock; | |
214 | ||
215 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); | |
216 | ||
8acf7a10 | 217 | if (!result && !ctx->more) { |
a8348bca HX |
218 | err = af_alg_wait_for_completion( |
219 | crypto_ahash_init(&ctx->req), | |
220 | &ctx->completion); | |
221 | if (err) | |
222 | goto unlock; | |
223 | } | |
224 | ||
225 | if (!result || ctx->more) { | |
fe869cdb | 226 | ctx->more = 0; |
fe869cdb HX |
227 | err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), |
228 | &ctx->completion); | |
229 | if (err) | |
230 | goto unlock; | |
231 | } | |
232 | ||
7eab8d9e | 233 | err = memcpy_to_msg(msg, ctx->result, len); |
fe869cdb HX |
234 | |
235 | unlock: | |
a8348bca | 236 | hash_free_result(sk, ctx); |
fe869cdb HX |
237 | release_sock(sk); |
238 | ||
239 | return err ?: len; | |
240 | } | |
241 | ||
cdfbabfb DH |
242 | static int hash_accept(struct socket *sock, struct socket *newsock, int flags, |
243 | bool kern) | |
fe869cdb HX |
244 | { |
245 | struct sock *sk = sock->sk; | |
246 | struct alg_sock *ask = alg_sk(sk); | |
247 | struct hash_ctx *ctx = ask->private; | |
248 | struct ahash_request *req = &ctx->req; | |
62071194 | 249 | char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req)) ? : 1]; |
fe869cdb HX |
250 | struct sock *sk2; |
251 | struct alg_sock *ask2; | |
252 | struct hash_ctx *ctx2; | |
4afa5f96 | 253 | bool more; |
fe869cdb HX |
254 | int err; |
255 | ||
4afa5f96 HX |
256 | lock_sock(sk); |
257 | more = ctx->more; | |
258 | err = more ? crypto_ahash_export(req, state) : 0; | |
259 | release_sock(sk); | |
260 | ||
fe869cdb HX |
261 | if (err) |
262 | return err; | |
263 | ||
cdfbabfb | 264 | err = af_alg_accept(ask->parent, newsock, kern); |
fe869cdb HX |
265 | if (err) |
266 | return err; | |
267 | ||
268 | sk2 = newsock->sk; | |
269 | ask2 = alg_sk(sk2); | |
270 | ctx2 = ask2->private; | |
4afa5f96 HX |
271 | ctx2->more = more; |
272 | ||
273 | if (!more) | |
274 | return err; | |
fe869cdb HX |
275 | |
276 | err = crypto_ahash_import(&ctx2->req, state); | |
277 | if (err) { | |
278 | sock_orphan(sk2); | |
279 | sock_put(sk2); | |
280 | } | |
281 | ||
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, | |
294 | .getsockopt = sock_no_getsockopt, | |
295 | .mmap = sock_no_mmap, | |
296 | .bind = sock_no_bind, | |
297 | .setsockopt = sock_no_setsockopt, | |
298 | .poll = sock_no_poll, | |
299 | ||
300 | .release = af_alg_release, | |
301 | .sendmsg = hash_sendmsg, | |
302 | .sendpage = hash_sendpage, | |
303 | .recvmsg = hash_recvmsg, | |
304 | .accept = hash_accept, | |
305 | }; | |
306 | ||
6de62f15 HX |
307 | static int hash_check_key(struct socket *sock) |
308 | { | |
ad46d7e3 | 309 | int err = 0; |
6de62f15 HX |
310 | struct sock *psk; |
311 | struct alg_sock *pask; | |
312 | struct algif_hash_tfm *tfm; | |
313 | struct sock *sk = sock->sk; | |
314 | struct alg_sock *ask = alg_sk(sk); | |
315 | ||
ad46d7e3 | 316 | lock_sock(sk); |
6de62f15 | 317 | if (ask->refcnt) |
ad46d7e3 | 318 | goto unlock_child; |
6de62f15 HX |
319 | |
320 | psk = ask->parent; | |
321 | pask = alg_sk(ask->parent); | |
322 | tfm = pask->private; | |
323 | ||
324 | err = -ENOKEY; | |
ad46d7e3 | 325 | lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
6de62f15 HX |
326 | if (!tfm->has_key) |
327 | goto unlock; | |
328 | ||
329 | if (!pask->refcnt++) | |
330 | sock_hold(psk); | |
331 | ||
332 | ask->refcnt = 1; | |
333 | sock_put(psk); | |
334 | ||
335 | err = 0; | |
336 | ||
337 | unlock: | |
338 | release_sock(psk); | |
ad46d7e3 HX |
339 | unlock_child: |
340 | release_sock(sk); | |
6de62f15 HX |
341 | |
342 | return err; | |
343 | } | |
344 | ||
345 | static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | |
346 | size_t size) | |
347 | { | |
348 | int err; | |
349 | ||
350 | err = hash_check_key(sock); | |
351 | if (err) | |
352 | return err; | |
353 | ||
354 | return hash_sendmsg(sock, msg, size); | |
355 | } | |
356 | ||
357 | static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, | |
358 | int offset, size_t size, int flags) | |
359 | { | |
360 | int err; | |
361 | ||
362 | err = hash_check_key(sock); | |
363 | if (err) | |
364 | return err; | |
365 | ||
366 | return hash_sendpage(sock, page, offset, size, flags); | |
367 | } | |
368 | ||
369 | static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | |
370 | size_t ignored, int flags) | |
371 | { | |
372 | int err; | |
373 | ||
374 | err = hash_check_key(sock); | |
375 | if (err) | |
376 | return err; | |
377 | ||
378 | return hash_recvmsg(sock, msg, ignored, flags); | |
379 | } | |
380 | ||
381 | static int hash_accept_nokey(struct socket *sock, struct socket *newsock, | |
cdfbabfb | 382 | int flags, bool kern) |
6de62f15 HX |
383 | { |
384 | int err; | |
385 | ||
386 | err = hash_check_key(sock); | |
387 | if (err) | |
388 | return err; | |
389 | ||
cdfbabfb | 390 | return hash_accept(sock, newsock, flags, kern); |
6de62f15 HX |
391 | } |
392 | ||
393 | static struct proto_ops algif_hash_ops_nokey = { | |
394 | .family = PF_ALG, | |
395 | ||
396 | .connect = sock_no_connect, | |
397 | .socketpair = sock_no_socketpair, | |
398 | .getname = sock_no_getname, | |
399 | .ioctl = sock_no_ioctl, | |
400 | .listen = sock_no_listen, | |
401 | .shutdown = sock_no_shutdown, | |
402 | .getsockopt = sock_no_getsockopt, | |
403 | .mmap = sock_no_mmap, | |
404 | .bind = sock_no_bind, | |
405 | .setsockopt = sock_no_setsockopt, | |
406 | .poll = sock_no_poll, | |
407 | ||
408 | .release = af_alg_release, | |
409 | .sendmsg = hash_sendmsg_nokey, | |
410 | .sendpage = hash_sendpage_nokey, | |
411 | .recvmsg = hash_recvmsg_nokey, | |
412 | .accept = hash_accept_nokey, | |
413 | }; | |
414 | ||
fe869cdb HX |
415 | static void *hash_bind(const char *name, u32 type, u32 mask) |
416 | { | |
6de62f15 HX |
417 | struct algif_hash_tfm *tfm; |
418 | struct crypto_ahash *hash; | |
419 | ||
420 | tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); | |
421 | if (!tfm) | |
422 | return ERR_PTR(-ENOMEM); | |
423 | ||
424 | hash = crypto_alloc_ahash(name, type, mask); | |
425 | if (IS_ERR(hash)) { | |
426 | kfree(tfm); | |
427 | return ERR_CAST(hash); | |
428 | } | |
429 | ||
430 | tfm->hash = hash; | |
431 | ||
432 | return tfm; | |
fe869cdb HX |
433 | } |
434 | ||
435 | static void hash_release(void *private) | |
436 | { | |
6de62f15 HX |
437 | struct algif_hash_tfm *tfm = private; |
438 | ||
439 | crypto_free_ahash(tfm->hash); | |
440 | kfree(tfm); | |
fe869cdb HX |
441 | } |
442 | ||
443 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) | |
444 | { | |
6de62f15 HX |
445 | struct algif_hash_tfm *tfm = private; |
446 | int err; | |
447 | ||
448 | err = crypto_ahash_setkey(tfm->hash, key, keylen); | |
449 | tfm->has_key = !err; | |
450 | ||
451 | return err; | |
fe869cdb HX |
452 | } |
453 | ||
f1d84af1 | 454 | static void hash_sock_destruct(struct sock *sk) |
fe869cdb HX |
455 | { |
456 | struct alg_sock *ask = alg_sk(sk); | |
457 | struct hash_ctx *ctx = ask->private; | |
458 | ||
493b2ed3 | 459 | hash_free_result(sk, ctx); |
fe869cdb | 460 | sock_kfree_s(sk, ctx, ctx->len); |
6de62f15 HX |
461 | af_alg_release_parent(sk); |
462 | } | |
463 | ||
f1d84af1 | 464 | static int hash_accept_parent_nokey(void *private, struct sock *sk) |
fe869cdb HX |
465 | { |
466 | struct hash_ctx *ctx; | |
467 | struct alg_sock *ask = alg_sk(sk); | |
6de62f15 HX |
468 | struct algif_hash_tfm *tfm = private; |
469 | struct crypto_ahash *hash = tfm->hash; | |
470 | unsigned len = sizeof(*ctx) + crypto_ahash_reqsize(hash); | |
fe869cdb HX |
471 | |
472 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | |
473 | if (!ctx) | |
474 | return -ENOMEM; | |
475 | ||
493b2ed3 | 476 | ctx->result = NULL; |
fe869cdb HX |
477 | ctx->len = len; |
478 | ctx->more = 0; | |
479 | af_alg_init_completion(&ctx->completion); | |
480 | ||
481 | ask->private = ctx; | |
482 | ||
6de62f15 | 483 | ahash_request_set_tfm(&ctx->req, hash); |
fe869cdb HX |
484 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
485 | af_alg_complete, &ctx->completion); | |
486 | ||
487 | sk->sk_destruct = hash_sock_destruct; | |
488 | ||
489 | return 0; | |
490 | } | |
491 | ||
6de62f15 HX |
492 | static int hash_accept_parent(void *private, struct sock *sk) |
493 | { | |
494 | struct algif_hash_tfm *tfm = private; | |
495 | ||
496 | if (!tfm->has_key && crypto_ahash_has_setkey(tfm->hash)) | |
497 | return -ENOKEY; | |
498 | ||
f1d84af1 | 499 | return hash_accept_parent_nokey(private, sk); |
6de62f15 HX |
500 | } |
501 | ||
fe869cdb HX |
502 | static const struct af_alg_type algif_type_hash = { |
503 | .bind = hash_bind, | |
504 | .release = hash_release, | |
505 | .setkey = hash_setkey, | |
506 | .accept = hash_accept_parent, | |
6de62f15 | 507 | .accept_nokey = hash_accept_parent_nokey, |
fe869cdb | 508 | .ops = &algif_hash_ops, |
6de62f15 | 509 | .ops_nokey = &algif_hash_ops_nokey, |
fe869cdb HX |
510 | .name = "hash", |
511 | .owner = THIS_MODULE | |
512 | }; | |
513 | ||
514 | static int __init algif_hash_init(void) | |
515 | { | |
516 | return af_alg_register_type(&algif_type_hash); | |
517 | } | |
518 | ||
519 | static void __exit algif_hash_exit(void) | |
520 | { | |
521 | int err = af_alg_unregister_type(&algif_type_hash); | |
522 | BUG_ON(err); | |
523 | } | |
524 | ||
525 | module_init(algif_hash_init); | |
526 | module_exit(algif_hash_exit); | |
527 | MODULE_LICENSE("GPL"); |