blob: 731b5fb8567b6b7bc116233c989271b18dbfe550
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 | |
37 | static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx) |
38 | { |
39 | unsigned ds; |
40 | |
41 | if (ctx->result) |
42 | return 0; |
43 | |
44 | ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); |
45 | |
46 | ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL); |
47 | if (!ctx->result) |
48 | return -ENOMEM; |
49 | |
50 | memset(ctx->result, 0, ds); |
51 | |
52 | return 0; |
53 | } |
54 | |
55 | static void hash_free_result(struct sock *sk, struct hash_ctx *ctx) |
56 | { |
57 | unsigned ds; |
58 | |
59 | if (!ctx->result) |
60 | return; |
61 | |
62 | ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); |
63 | |
64 | sock_kzfree_s(sk, ctx->result, ds); |
65 | ctx->result = NULL; |
66 | } |
67 | |
68 | static int hash_sendmsg(struct socket *sock, struct msghdr *msg, |
69 | size_t ignored) |
70 | { |
71 | int limit = ALG_MAX_PAGES * PAGE_SIZE; |
72 | struct sock *sk = sock->sk; |
73 | struct alg_sock *ask = alg_sk(sk); |
74 | struct hash_ctx *ctx = ask->private; |
75 | long copied = 0; |
76 | int err; |
77 | |
78 | if (limit > sk->sk_sndbuf) |
79 | limit = sk->sk_sndbuf; |
80 | |
81 | lock_sock(sk); |
82 | if (!ctx->more) { |
83 | if ((msg->msg_flags & MSG_MORE)) |
84 | hash_free_result(sk, ctx); |
85 | |
86 | err = af_alg_wait_for_completion(crypto_ahash_init(&ctx->req), |
87 | &ctx->completion); |
88 | if (err) |
89 | goto unlock; |
90 | } |
91 | |
92 | ctx->more = 0; |
93 | |
94 | while (msg_data_left(msg)) { |
95 | int len = msg_data_left(msg); |
96 | |
97 | if (len > limit) |
98 | len = limit; |
99 | |
100 | len = af_alg_make_sg(&ctx->sgl, &msg->msg_iter, len); |
101 | if (len < 0) { |
102 | err = copied ? 0 : len; |
103 | goto unlock; |
104 | } |
105 | |
106 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, NULL, len); |
107 | |
108 | err = af_alg_wait_for_completion(crypto_ahash_update(&ctx->req), |
109 | &ctx->completion); |
110 | af_alg_free_sg(&ctx->sgl); |
111 | if (err) |
112 | goto unlock; |
113 | |
114 | copied += len; |
115 | iov_iter_advance(&msg->msg_iter, len); |
116 | } |
117 | |
118 | err = 0; |
119 | |
120 | ctx->more = msg->msg_flags & MSG_MORE; |
121 | if (!ctx->more) { |
122 | err = hash_alloc_result(sk, ctx); |
123 | if (err) |
124 | goto unlock; |
125 | |
126 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); |
127 | err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), |
128 | &ctx->completion); |
129 | } |
130 | |
131 | unlock: |
132 | release_sock(sk); |
133 | |
134 | return err ?: copied; |
135 | } |
136 | |
137 | static ssize_t hash_sendpage(struct socket *sock, struct page *page, |
138 | int offset, size_t size, int flags) |
139 | { |
140 | struct sock *sk = sock->sk; |
141 | struct alg_sock *ask = alg_sk(sk); |
142 | struct hash_ctx *ctx = ask->private; |
143 | int err; |
144 | |
145 | if (flags & MSG_SENDPAGE_NOTLAST) |
146 | flags |= MSG_MORE; |
147 | |
148 | lock_sock(sk); |
149 | sg_init_table(ctx->sgl.sg, 1); |
150 | sg_set_page(ctx->sgl.sg, page, size, offset); |
151 | |
152 | if (!(flags & MSG_MORE)) { |
153 | err = hash_alloc_result(sk, ctx); |
154 | if (err) |
155 | goto unlock; |
156 | } else if (!ctx->more) |
157 | hash_free_result(sk, ctx); |
158 | |
159 | ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, ctx->result, size); |
160 | |
161 | if (!(flags & MSG_MORE)) { |
162 | if (ctx->more) |
163 | err = crypto_ahash_finup(&ctx->req); |
164 | else |
165 | err = crypto_ahash_digest(&ctx->req); |
166 | } else { |
167 | if (!ctx->more) { |
168 | err = crypto_ahash_init(&ctx->req); |
169 | err = af_alg_wait_for_completion(err, &ctx->completion); |
170 | if (err) |
171 | goto unlock; |
172 | } |
173 | |
174 | err = crypto_ahash_update(&ctx->req); |
175 | } |
176 | |
177 | err = af_alg_wait_for_completion(err, &ctx->completion); |
178 | if (err) |
179 | goto unlock; |
180 | |
181 | ctx->more = flags & MSG_MORE; |
182 | |
183 | unlock: |
184 | release_sock(sk); |
185 | |
186 | return err ?: size; |
187 | } |
188 | |
189 | static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, |
190 | int flags) |
191 | { |
192 | struct sock *sk = sock->sk; |
193 | struct alg_sock *ask = alg_sk(sk); |
194 | struct hash_ctx *ctx = ask->private; |
195 | unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); |
196 | bool result; |
197 | int err; |
198 | |
199 | if (len > ds) |
200 | len = ds; |
201 | else if (len < ds) |
202 | msg->msg_flags |= MSG_TRUNC; |
203 | |
204 | lock_sock(sk); |
205 | result = ctx->result; |
206 | err = hash_alloc_result(sk, ctx); |
207 | if (err) |
208 | goto unlock; |
209 | |
210 | ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); |
211 | |
212 | if (!result && !ctx->more) { |
213 | err = af_alg_wait_for_completion( |
214 | crypto_ahash_init(&ctx->req), |
215 | &ctx->completion); |
216 | if (err) |
217 | goto unlock; |
218 | } |
219 | |
220 | if (!result || ctx->more) { |
221 | ctx->more = 0; |
222 | err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), |
223 | &ctx->completion); |
224 | if (err) |
225 | goto unlock; |
226 | } |
227 | |
228 | err = memcpy_to_msg(msg, ctx->result, len); |
229 | |
230 | unlock: |
231 | hash_free_result(sk, ctx); |
232 | release_sock(sk); |
233 | |
234 | return err ?: len; |
235 | } |
236 | |
237 | static int hash_accept(struct socket *sock, struct socket *newsock, int flags) |
238 | { |
239 | struct sock *sk = sock->sk; |
240 | struct alg_sock *ask = alg_sk(sk); |
241 | struct hash_ctx *ctx = ask->private; |
242 | struct ahash_request *req = &ctx->req; |
243 | char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req)) ? : 1]; |
244 | struct sock *sk2; |
245 | struct alg_sock *ask2; |
246 | struct hash_ctx *ctx2; |
247 | bool more; |
248 | int err; |
249 | |
250 | lock_sock(sk); |
251 | more = ctx->more; |
252 | err = more ? crypto_ahash_export(req, state) : 0; |
253 | release_sock(sk); |
254 | |
255 | if (err) |
256 | return err; |
257 | |
258 | err = af_alg_accept(ask->parent, newsock); |
259 | if (err) |
260 | return err; |
261 | |
262 | sk2 = newsock->sk; |
263 | ask2 = alg_sk(sk2); |
264 | ctx2 = ask2->private; |
265 | ctx2->more = more; |
266 | |
267 | if (!more) |
268 | return err; |
269 | |
270 | err = crypto_ahash_import(&ctx2->req, state); |
271 | if (err) { |
272 | sock_orphan(sk2); |
273 | sock_put(sk2); |
274 | } |
275 | |
276 | return err; |
277 | } |
278 | |
279 | static struct proto_ops algif_hash_ops = { |
280 | .family = PF_ALG, |
281 | |
282 | .connect = sock_no_connect, |
283 | .socketpair = sock_no_socketpair, |
284 | .getname = sock_no_getname, |
285 | .ioctl = sock_no_ioctl, |
286 | .listen = sock_no_listen, |
287 | .shutdown = sock_no_shutdown, |
288 | .getsockopt = sock_no_getsockopt, |
289 | .mmap = sock_no_mmap, |
290 | .bind = sock_no_bind, |
291 | .setsockopt = sock_no_setsockopt, |
292 | .poll = sock_no_poll, |
293 | |
294 | .release = af_alg_release, |
295 | .sendmsg = hash_sendmsg, |
296 | .sendpage = hash_sendpage, |
297 | .recvmsg = hash_recvmsg, |
298 | .accept = hash_accept, |
299 | }; |
300 | |
301 | static int hash_check_key(struct socket *sock) |
302 | { |
303 | int err = 0; |
304 | struct sock *psk; |
305 | struct alg_sock *pask; |
306 | struct crypto_ahash *tfm; |
307 | struct sock *sk = sock->sk; |
308 | struct alg_sock *ask = alg_sk(sk); |
309 | |
310 | lock_sock(sk); |
311 | if (ask->refcnt) |
312 | goto unlock_child; |
313 | |
314 | psk = ask->parent; |
315 | pask = alg_sk(ask->parent); |
316 | tfm = pask->private; |
317 | |
318 | err = -ENOKEY; |
319 | lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
320 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
321 | goto unlock; |
322 | |
323 | if (!pask->refcnt++) |
324 | sock_hold(psk); |
325 | |
326 | ask->refcnt = 1; |
327 | sock_put(psk); |
328 | |
329 | err = 0; |
330 | |
331 | unlock: |
332 | release_sock(psk); |
333 | unlock_child: |
334 | release_sock(sk); |
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, |
376 | int flags) |
377 | { |
378 | int err; |
379 | |
380 | err = hash_check_key(sock); |
381 | if (err) |
382 | return err; |
383 | |
384 | return hash_accept(sock, newsock, flags); |
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, |
396 | .getsockopt = sock_no_getsockopt, |
397 | .mmap = sock_no_mmap, |
398 | .bind = sock_no_bind, |
399 | .setsockopt = sock_no_setsockopt, |
400 | .poll = sock_no_poll, |
401 | |
402 | .release = af_alg_release, |
403 | .sendmsg = hash_sendmsg_nokey, |
404 | .sendpage = hash_sendpage_nokey, |
405 | .recvmsg = hash_recvmsg_nokey, |
406 | .accept = hash_accept_nokey, |
407 | }; |
408 | |
409 | static void *hash_bind(const char *name, u32 type, u32 mask) |
410 | { |
411 | return crypto_alloc_ahash(name, type, mask); |
412 | } |
413 | |
414 | static void hash_release(void *private) |
415 | { |
416 | crypto_free_ahash(private); |
417 | } |
418 | |
419 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) |
420 | { |
421 | return crypto_ahash_setkey(private, key, keylen); |
422 | } |
423 | |
424 | static void hash_sock_destruct(struct sock *sk) |
425 | { |
426 | struct alg_sock *ask = alg_sk(sk); |
427 | struct hash_ctx *ctx = ask->private; |
428 | |
429 | hash_free_result(sk, ctx); |
430 | sock_kfree_s(sk, ctx, ctx->len); |
431 | af_alg_release_parent(sk); |
432 | } |
433 | |
434 | static int hash_accept_parent_nokey(void *private, struct sock *sk) |
435 | { |
436 | struct crypto_ahash *tfm = private; |
437 | struct alg_sock *ask = alg_sk(sk); |
438 | struct hash_ctx *ctx; |
439 | unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm); |
440 | |
441 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); |
442 | if (!ctx) |
443 | return -ENOMEM; |
444 | |
445 | ctx->result = NULL; |
446 | ctx->len = len; |
447 | ctx->more = 0; |
448 | af_alg_init_completion(&ctx->completion); |
449 | |
450 | ask->private = ctx; |
451 | |
452 | ahash_request_set_tfm(&ctx->req, tfm); |
453 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
454 | af_alg_complete, &ctx->completion); |
455 | |
456 | sk->sk_destruct = hash_sock_destruct; |
457 | |
458 | return 0; |
459 | } |
460 | |
461 | static int hash_accept_parent(void *private, struct sock *sk) |
462 | { |
463 | struct crypto_ahash *tfm = private; |
464 | |
465 | if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) |
466 | return -ENOKEY; |
467 | |
468 | return hash_accept_parent_nokey(private, sk); |
469 | } |
470 | |
471 | static const struct af_alg_type algif_type_hash = { |
472 | .bind = hash_bind, |
473 | .release = hash_release, |
474 | .setkey = hash_setkey, |
475 | .accept = hash_accept_parent, |
476 | .accept_nokey = hash_accept_parent_nokey, |
477 | .ops = &algif_hash_ops, |
478 | .ops_nokey = &algif_hash_ops_nokey, |
479 | .name = "hash", |
480 | .owner = THIS_MODULE |
481 | }; |
482 | |
483 | static int __init algif_hash_init(void) |
484 | { |
485 | return af_alg_register_type(&algif_type_hash); |
486 | } |
487 | |
488 | static void __exit algif_hash_exit(void) |
489 | { |
490 | int err = af_alg_unregister_type(&algif_type_hash); |
491 | BUG_ON(err); |
492 | } |
493 | |
494 | module_init(algif_hash_init); |
495 | module_exit(algif_hash_exit); |
496 | MODULE_LICENSE("GPL"); |
497 |