]>
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 | ||
fe869cdb HX |
217 | if (ctx->more) { |
218 | ctx->more = 0; | |
fe869cdb HX |
219 | err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), |
220 | &ctx->completion); | |
221 | if (err) | |
222 | goto unlock; | |
493b2ed3 HX |
223 | } else if (!result) { |
224 | err = af_alg_wait_for_completion( | |
225 | crypto_ahash_digest(&ctx->req), | |
226 | &ctx->completion); | |
fe869cdb HX |
227 | } |
228 | ||
7eab8d9e | 229 | err = memcpy_to_msg(msg, ctx->result, len); |
fe869cdb | 230 | |
493b2ed3 HX |
231 | hash_free_result(sk, ctx); |
232 | ||
fe869cdb HX |
233 | unlock: |
234 | release_sock(sk); | |
235 | ||
236 | return err ?: len; | |
237 | } | |
238 | ||
239 | static int hash_accept(struct socket *sock, struct socket *newsock, int flags) | |
240 | { | |
241 | struct sock *sk = sock->sk; | |
242 | struct alg_sock *ask = alg_sk(sk); | |
243 | struct hash_ctx *ctx = ask->private; | |
244 | struct ahash_request *req = &ctx->req; | |
245 | char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req))]; | |
246 | struct sock *sk2; | |
247 | struct alg_sock *ask2; | |
248 | struct hash_ctx *ctx2; | |
4afa5f96 | 249 | bool more; |
fe869cdb HX |
250 | int err; |
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 HX |
257 | if (err) |
258 | return err; | |
259 | ||
260 | err = af_alg_accept(ask->parent, newsock); | |
261 | if (err) | |
262 | return err; | |
263 | ||
264 | sk2 = newsock->sk; | |
265 | ask2 = alg_sk(sk2); | |
266 | ctx2 = ask2->private; | |
4afa5f96 HX |
267 | ctx2->more = more; |
268 | ||
269 | if (!more) | |
270 | return err; | |
fe869cdb HX |
271 | |
272 | err = crypto_ahash_import(&ctx2->req, state); | |
273 | if (err) { | |
274 | sock_orphan(sk2); | |
275 | sock_put(sk2); | |
276 | } | |
277 | ||
278 | return err; | |
279 | } | |
280 | ||
281 | static struct proto_ops algif_hash_ops = { | |
282 | .family = PF_ALG, | |
283 | ||
284 | .connect = sock_no_connect, | |
285 | .socketpair = sock_no_socketpair, | |
286 | .getname = sock_no_getname, | |
287 | .ioctl = sock_no_ioctl, | |
288 | .listen = sock_no_listen, | |
289 | .shutdown = sock_no_shutdown, | |
290 | .getsockopt = sock_no_getsockopt, | |
291 | .mmap = sock_no_mmap, | |
292 | .bind = sock_no_bind, | |
293 | .setsockopt = sock_no_setsockopt, | |
294 | .poll = sock_no_poll, | |
295 | ||
296 | .release = af_alg_release, | |
297 | .sendmsg = hash_sendmsg, | |
298 | .sendpage = hash_sendpage, | |
299 | .recvmsg = hash_recvmsg, | |
300 | .accept = hash_accept, | |
301 | }; | |
302 | ||
6de62f15 HX |
303 | static int hash_check_key(struct socket *sock) |
304 | { | |
ad46d7e3 | 305 | int err = 0; |
6de62f15 HX |
306 | struct sock *psk; |
307 | struct alg_sock *pask; | |
308 | struct algif_hash_tfm *tfm; | |
309 | struct sock *sk = sock->sk; | |
310 | struct alg_sock *ask = alg_sk(sk); | |
311 | ||
ad46d7e3 | 312 | lock_sock(sk); |
6de62f15 | 313 | if (ask->refcnt) |
ad46d7e3 | 314 | goto unlock_child; |
6de62f15 HX |
315 | |
316 | psk = ask->parent; | |
317 | pask = alg_sk(ask->parent); | |
318 | tfm = pask->private; | |
319 | ||
320 | err = -ENOKEY; | |
ad46d7e3 | 321 | lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
6de62f15 HX |
322 | if (!tfm->has_key) |
323 | goto unlock; | |
324 | ||
325 | if (!pask->refcnt++) | |
326 | sock_hold(psk); | |
327 | ||
328 | ask->refcnt = 1; | |
329 | sock_put(psk); | |
330 | ||
331 | err = 0; | |
332 | ||
333 | unlock: | |
334 | release_sock(psk); | |
ad46d7e3 HX |
335 | unlock_child: |
336 | release_sock(sk); | |
6de62f15 HX |
337 | |
338 | return err; | |
339 | } | |
340 | ||
341 | static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | |
342 | size_t size) | |
343 | { | |
344 | int err; | |
345 | ||
346 | err = hash_check_key(sock); | |
347 | if (err) | |
348 | return err; | |
349 | ||
350 | return hash_sendmsg(sock, msg, size); | |
351 | } | |
352 | ||
353 | static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, | |
354 | int offset, size_t size, int flags) | |
355 | { | |
356 | int err; | |
357 | ||
358 | err = hash_check_key(sock); | |
359 | if (err) | |
360 | return err; | |
361 | ||
362 | return hash_sendpage(sock, page, offset, size, flags); | |
363 | } | |
364 | ||
365 | static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | |
366 | size_t ignored, int flags) | |
367 | { | |
368 | int err; | |
369 | ||
370 | err = hash_check_key(sock); | |
371 | if (err) | |
372 | return err; | |
373 | ||
374 | return hash_recvmsg(sock, msg, ignored, flags); | |
375 | } | |
376 | ||
377 | static int hash_accept_nokey(struct socket *sock, struct socket *newsock, | |
378 | int flags) | |
379 | { | |
380 | int err; | |
381 | ||
382 | err = hash_check_key(sock); | |
383 | if (err) | |
384 | return err; | |
385 | ||
386 | return hash_accept(sock, newsock, flags); | |
387 | } | |
388 | ||
389 | static struct proto_ops algif_hash_ops_nokey = { | |
390 | .family = PF_ALG, | |
391 | ||
392 | .connect = sock_no_connect, | |
393 | .socketpair = sock_no_socketpair, | |
394 | .getname = sock_no_getname, | |
395 | .ioctl = sock_no_ioctl, | |
396 | .listen = sock_no_listen, | |
397 | .shutdown = sock_no_shutdown, | |
398 | .getsockopt = sock_no_getsockopt, | |
399 | .mmap = sock_no_mmap, | |
400 | .bind = sock_no_bind, | |
401 | .setsockopt = sock_no_setsockopt, | |
402 | .poll = sock_no_poll, | |
403 | ||
404 | .release = af_alg_release, | |
405 | .sendmsg = hash_sendmsg_nokey, | |
406 | .sendpage = hash_sendpage_nokey, | |
407 | .recvmsg = hash_recvmsg_nokey, | |
408 | .accept = hash_accept_nokey, | |
409 | }; | |
410 | ||
fe869cdb HX |
411 | static void *hash_bind(const char *name, u32 type, u32 mask) |
412 | { | |
6de62f15 HX |
413 | struct algif_hash_tfm *tfm; |
414 | struct crypto_ahash *hash; | |
415 | ||
416 | tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); | |
417 | if (!tfm) | |
418 | return ERR_PTR(-ENOMEM); | |
419 | ||
420 | hash = crypto_alloc_ahash(name, type, mask); | |
421 | if (IS_ERR(hash)) { | |
422 | kfree(tfm); | |
423 | return ERR_CAST(hash); | |
424 | } | |
425 | ||
426 | tfm->hash = hash; | |
427 | ||
428 | return tfm; | |
fe869cdb HX |
429 | } |
430 | ||
431 | static void hash_release(void *private) | |
432 | { | |
6de62f15 HX |
433 | struct algif_hash_tfm *tfm = private; |
434 | ||
435 | crypto_free_ahash(tfm->hash); | |
436 | kfree(tfm); | |
fe869cdb HX |
437 | } |
438 | ||
439 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) | |
440 | { | |
6de62f15 HX |
441 | struct algif_hash_tfm *tfm = private; |
442 | int err; | |
443 | ||
444 | err = crypto_ahash_setkey(tfm->hash, key, keylen); | |
445 | tfm->has_key = !err; | |
446 | ||
447 | return err; | |
fe869cdb HX |
448 | } |
449 | ||
f1d84af1 | 450 | static void hash_sock_destruct(struct sock *sk) |
fe869cdb HX |
451 | { |
452 | struct alg_sock *ask = alg_sk(sk); | |
453 | struct hash_ctx *ctx = ask->private; | |
454 | ||
493b2ed3 | 455 | hash_free_result(sk, ctx); |
fe869cdb | 456 | sock_kfree_s(sk, ctx, ctx->len); |
6de62f15 HX |
457 | af_alg_release_parent(sk); |
458 | } | |
459 | ||
f1d84af1 | 460 | static int hash_accept_parent_nokey(void *private, struct sock *sk) |
fe869cdb HX |
461 | { |
462 | struct hash_ctx *ctx; | |
463 | struct alg_sock *ask = alg_sk(sk); | |
6de62f15 HX |
464 | struct algif_hash_tfm *tfm = private; |
465 | struct crypto_ahash *hash = tfm->hash; | |
466 | unsigned len = sizeof(*ctx) + crypto_ahash_reqsize(hash); | |
fe869cdb HX |
467 | |
468 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | |
469 | if (!ctx) | |
470 | return -ENOMEM; | |
471 | ||
493b2ed3 | 472 | ctx->result = NULL; |
fe869cdb HX |
473 | ctx->len = len; |
474 | ctx->more = 0; | |
475 | af_alg_init_completion(&ctx->completion); | |
476 | ||
477 | ask->private = ctx; | |
478 | ||
6de62f15 | 479 | ahash_request_set_tfm(&ctx->req, hash); |
fe869cdb HX |
480 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
481 | af_alg_complete, &ctx->completion); | |
482 | ||
483 | sk->sk_destruct = hash_sock_destruct; | |
484 | ||
485 | return 0; | |
486 | } | |
487 | ||
6de62f15 HX |
488 | static int hash_accept_parent(void *private, struct sock *sk) |
489 | { | |
490 | struct algif_hash_tfm *tfm = private; | |
491 | ||
492 | if (!tfm->has_key && crypto_ahash_has_setkey(tfm->hash)) | |
493 | return -ENOKEY; | |
494 | ||
f1d84af1 | 495 | return hash_accept_parent_nokey(private, sk); |
6de62f15 HX |
496 | } |
497 | ||
fe869cdb HX |
498 | static const struct af_alg_type algif_type_hash = { |
499 | .bind = hash_bind, | |
500 | .release = hash_release, | |
501 | .setkey = hash_setkey, | |
502 | .accept = hash_accept_parent, | |
6de62f15 | 503 | .accept_nokey = hash_accept_parent_nokey, |
fe869cdb | 504 | .ops = &algif_hash_ops, |
6de62f15 | 505 | .ops_nokey = &algif_hash_ops_nokey, |
fe869cdb HX |
506 | .name = "hash", |
507 | .owner = THIS_MODULE | |
508 | }; | |
509 | ||
510 | static int __init algif_hash_init(void) | |
511 | { | |
512 | return af_alg_register_type(&algif_type_hash); | |
513 | } | |
514 | ||
515 | static void __exit algif_hash_exit(void) | |
516 | { | |
517 | int err = af_alg_unregister_type(&algif_type_hash); | |
518 | BUG_ON(err); | |
519 | } | |
520 | ||
521 | module_init(algif_hash_init); | |
522 | module_exit(algif_hash_exit); | |
523 | MODULE_LICENSE("GPL"); |