2 * algif_hash: User-space interface for hash algorithms
4 * This file provides the user-space API for hash algorithms.
6 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
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)
15 #include <crypto/hash.h>
16 #include <crypto/if_alg.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/net.h>
25 struct af_alg_sgl sgl
;
29 struct af_alg_completion completion
;
34 struct ahash_request req
;
37 struct algif_hash_tfm
{
38 struct crypto_ahash
*hash
;
42 static int hash_sendmsg(struct socket
*sock
, struct msghdr
*msg
,
45 int limit
= ALG_MAX_PAGES
* PAGE_SIZE
;
46 struct sock
*sk
= sock
->sk
;
47 struct alg_sock
*ask
= alg_sk(sk
);
48 struct hash_ctx
*ctx
= ask
->private;
52 if (limit
> sk
->sk_sndbuf
)
53 limit
= sk
->sk_sndbuf
;
57 err
= crypto_ahash_init(&ctx
->req
);
64 while (msg_data_left(msg
)) {
65 int len
= msg_data_left(msg
);
70 len
= af_alg_make_sg(&ctx
->sgl
, &msg
->msg_iter
, len
);
72 err
= copied
? 0 : len
;
76 ahash_request_set_crypt(&ctx
->req
, ctx
->sgl
.sg
, NULL
, len
);
78 err
= af_alg_wait_for_completion(crypto_ahash_update(&ctx
->req
),
80 af_alg_free_sg(&ctx
->sgl
);
85 iov_iter_advance(&msg
->msg_iter
, len
);
90 ctx
->more
= msg
->msg_flags
& MSG_MORE
;
92 ahash_request_set_crypt(&ctx
->req
, NULL
, ctx
->result
, 0);
93 err
= af_alg_wait_for_completion(crypto_ahash_final(&ctx
->req
),
100 return err
?: copied
;
103 static ssize_t
hash_sendpage(struct socket
*sock
, struct page
*page
,
104 int offset
, size_t size
, int flags
)
106 struct sock
*sk
= sock
->sk
;
107 struct alg_sock
*ask
= alg_sk(sk
);
108 struct hash_ctx
*ctx
= ask
->private;
111 if (flags
& MSG_SENDPAGE_NOTLAST
)
115 sg_init_table(ctx
->sgl
.sg
, 1);
116 sg_set_page(ctx
->sgl
.sg
, page
, size
, offset
);
118 ahash_request_set_crypt(&ctx
->req
, ctx
->sgl
.sg
, ctx
->result
, size
);
120 if (!(flags
& MSG_MORE
)) {
122 err
= crypto_ahash_finup(&ctx
->req
);
124 err
= crypto_ahash_digest(&ctx
->req
);
127 err
= crypto_ahash_init(&ctx
->req
);
132 err
= crypto_ahash_update(&ctx
->req
);
135 err
= af_alg_wait_for_completion(err
, &ctx
->completion
);
139 ctx
->more
= flags
& MSG_MORE
;
147 static int hash_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
,
150 struct sock
*sk
= sock
->sk
;
151 struct alg_sock
*ask
= alg_sk(sk
);
152 struct hash_ctx
*ctx
= ask
->private;
153 unsigned ds
= crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
));
159 msg
->msg_flags
|= MSG_TRUNC
;
164 ahash_request_set_crypt(&ctx
->req
, NULL
, ctx
->result
, 0);
165 err
= af_alg_wait_for_completion(crypto_ahash_final(&ctx
->req
),
171 err
= memcpy_to_msg(msg
, ctx
->result
, len
);
179 static int hash_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
181 struct sock
*sk
= sock
->sk
;
182 struct alg_sock
*ask
= alg_sk(sk
);
183 struct hash_ctx
*ctx
= ask
->private;
184 struct ahash_request
*req
= &ctx
->req
;
185 char state
[crypto_ahash_statesize(crypto_ahash_reqtfm(req
))];
187 struct alg_sock
*ask2
;
188 struct hash_ctx
*ctx2
;
194 err
= more
? crypto_ahash_export(req
, state
) : 0;
200 err
= af_alg_accept(ask
->parent
, newsock
);
206 ctx2
= ask2
->private;
212 err
= crypto_ahash_import(&ctx2
->req
, state
);
221 static struct proto_ops algif_hash_ops
= {
224 .connect
= sock_no_connect
,
225 .socketpair
= sock_no_socketpair
,
226 .getname
= sock_no_getname
,
227 .ioctl
= sock_no_ioctl
,
228 .listen
= sock_no_listen
,
229 .shutdown
= sock_no_shutdown
,
230 .getsockopt
= sock_no_getsockopt
,
231 .mmap
= sock_no_mmap
,
232 .bind
= sock_no_bind
,
233 .setsockopt
= sock_no_setsockopt
,
234 .poll
= sock_no_poll
,
236 .release
= af_alg_release
,
237 .sendmsg
= hash_sendmsg
,
238 .sendpage
= hash_sendpage
,
239 .recvmsg
= hash_recvmsg
,
240 .accept
= hash_accept
,
243 static int hash_check_key(struct socket
*sock
)
247 struct alg_sock
*pask
;
248 struct algif_hash_tfm
*tfm
;
249 struct sock
*sk
= sock
->sk
;
250 struct alg_sock
*ask
= alg_sk(sk
);
256 pask
= alg_sk(ask
->parent
);
278 static int hash_sendmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
283 err
= hash_check_key(sock
);
287 return hash_sendmsg(sock
, msg
, size
);
290 static ssize_t
hash_sendpage_nokey(struct socket
*sock
, struct page
*page
,
291 int offset
, size_t size
, int flags
)
295 err
= hash_check_key(sock
);
299 return hash_sendpage(sock
, page
, offset
, size
, flags
);
302 static int hash_recvmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
303 size_t ignored
, int flags
)
307 err
= hash_check_key(sock
);
311 return hash_recvmsg(sock
, msg
, ignored
, flags
);
314 static int hash_accept_nokey(struct socket
*sock
, struct socket
*newsock
,
319 err
= hash_check_key(sock
);
323 return hash_accept(sock
, newsock
, flags
);
326 static struct proto_ops algif_hash_ops_nokey
= {
329 .connect
= sock_no_connect
,
330 .socketpair
= sock_no_socketpair
,
331 .getname
= sock_no_getname
,
332 .ioctl
= sock_no_ioctl
,
333 .listen
= sock_no_listen
,
334 .shutdown
= sock_no_shutdown
,
335 .getsockopt
= sock_no_getsockopt
,
336 .mmap
= sock_no_mmap
,
337 .bind
= sock_no_bind
,
338 .setsockopt
= sock_no_setsockopt
,
339 .poll
= sock_no_poll
,
341 .release
= af_alg_release
,
342 .sendmsg
= hash_sendmsg_nokey
,
343 .sendpage
= hash_sendpage_nokey
,
344 .recvmsg
= hash_recvmsg_nokey
,
345 .accept
= hash_accept_nokey
,
348 static void *hash_bind(const char *name
, u32 type
, u32 mask
)
350 struct algif_hash_tfm
*tfm
;
351 struct crypto_ahash
*hash
;
353 tfm
= kzalloc(sizeof(*tfm
), GFP_KERNEL
);
355 return ERR_PTR(-ENOMEM
);
357 hash
= crypto_alloc_ahash(name
, type
, mask
);
360 return ERR_CAST(hash
);
368 static void hash_release(void *private)
370 struct algif_hash_tfm
*tfm
= private;
372 crypto_free_ahash(tfm
->hash
);
376 static int hash_setkey(void *private, const u8
*key
, unsigned int keylen
)
378 struct algif_hash_tfm
*tfm
= private;
381 err
= crypto_ahash_setkey(tfm
->hash
, key
, keylen
);
387 static void hash_sock_destruct(struct sock
*sk
)
389 struct alg_sock
*ask
= alg_sk(sk
);
390 struct hash_ctx
*ctx
= ask
->private;
392 sock_kzfree_s(sk
, ctx
->result
,
393 crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
)));
394 sock_kfree_s(sk
, ctx
, ctx
->len
);
395 af_alg_release_parent(sk
);
398 static int hash_accept_parent_nokey(void *private, struct sock
*sk
)
400 struct hash_ctx
*ctx
;
401 struct alg_sock
*ask
= alg_sk(sk
);
402 struct algif_hash_tfm
*tfm
= private;
403 struct crypto_ahash
*hash
= tfm
->hash
;
404 unsigned len
= sizeof(*ctx
) + crypto_ahash_reqsize(hash
);
405 unsigned ds
= crypto_ahash_digestsize(hash
);
407 ctx
= sock_kmalloc(sk
, len
, GFP_KERNEL
);
411 ctx
->result
= sock_kmalloc(sk
, ds
, GFP_KERNEL
);
413 sock_kfree_s(sk
, ctx
, len
);
417 memset(ctx
->result
, 0, ds
);
421 af_alg_init_completion(&ctx
->completion
);
425 ahash_request_set_tfm(&ctx
->req
, hash
);
426 ahash_request_set_callback(&ctx
->req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
427 af_alg_complete
, &ctx
->completion
);
429 sk
->sk_destruct
= hash_sock_destruct
;
434 static int hash_accept_parent(void *private, struct sock
*sk
)
436 struct algif_hash_tfm
*tfm
= private;
438 if (!tfm
->has_key
&& crypto_ahash_has_setkey(tfm
->hash
))
441 return hash_accept_parent_nokey(private, sk
);
444 static const struct af_alg_type algif_type_hash
= {
446 .release
= hash_release
,
447 .setkey
= hash_setkey
,
448 .accept
= hash_accept_parent
,
449 .accept_nokey
= hash_accept_parent_nokey
,
450 .ops
= &algif_hash_ops
,
451 .ops_nokey
= &algif_hash_ops_nokey
,
456 static int __init
algif_hash_init(void)
458 return af_alg_register_type(&algif_type_hash
);
461 static void __exit
algif_hash_exit(void)
463 int err
= af_alg_unregister_type(&algif_type_hash
);
467 module_init(algif_hash_init
);
468 module_exit(algif_hash_exit
);
469 MODULE_LICENSE("GPL");