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 static int hash_sendmsg(struct kiocb
*unused
, struct socket
*sock
,
38 struct msghdr
*msg
, size_t ignored
)
40 int limit
= ALG_MAX_PAGES
* PAGE_SIZE
;
41 struct sock
*sk
= sock
->sk
;
42 struct alg_sock
*ask
= alg_sk(sk
);
43 struct hash_ctx
*ctx
= ask
->private;
49 if (limit
> sk
->sk_sndbuf
)
50 limit
= sk
->sk_sndbuf
;
54 err
= af_alg_wait_for_completion(crypto_ahash_init(&ctx
->req
),
62 for (iov
= msg
->msg_iov
, iovlen
= msg
->msg_iovlen
; iovlen
> 0;
64 unsigned long seglen
= iov
->iov_len
;
65 char __user
*from
= iov
->iov_base
;
68 int len
= min_t(unsigned long, seglen
, limit
);
71 newlen
= af_alg_make_sg(&ctx
->sgl
, from
, len
, 0);
73 err
= copied
? 0 : newlen
;
77 ahash_request_set_crypt(&ctx
->req
, ctx
->sgl
.sg
, NULL
,
80 err
= af_alg_wait_for_completion(
81 crypto_ahash_update(&ctx
->req
),
84 af_alg_free_sg(&ctx
->sgl
);
97 ctx
->more
= msg
->msg_flags
& MSG_MORE
;
99 ahash_request_set_crypt(&ctx
->req
, NULL
, ctx
->result
, 0);
100 err
= af_alg_wait_for_completion(crypto_ahash_final(&ctx
->req
),
107 return err
?: copied
;
110 static ssize_t
hash_sendpage(struct socket
*sock
, struct page
*page
,
111 int offset
, size_t size
, int flags
)
113 struct sock
*sk
= sock
->sk
;
114 struct alg_sock
*ask
= alg_sk(sk
);
115 struct hash_ctx
*ctx
= ask
->private;
118 if (flags
& MSG_SENDPAGE_NOTLAST
)
122 sg_init_table(ctx
->sgl
.sg
, 1);
123 sg_set_page(ctx
->sgl
.sg
, page
, size
, offset
);
125 ahash_request_set_crypt(&ctx
->req
, ctx
->sgl
.sg
, ctx
->result
, size
);
127 if (!(flags
& MSG_MORE
)) {
129 err
= crypto_ahash_finup(&ctx
->req
);
131 err
= crypto_ahash_digest(&ctx
->req
);
134 err
= crypto_ahash_init(&ctx
->req
);
135 err
= af_alg_wait_for_completion(err
, &ctx
->completion
);
140 err
= crypto_ahash_update(&ctx
->req
);
143 err
= af_alg_wait_for_completion(err
, &ctx
->completion
);
147 ctx
->more
= flags
& MSG_MORE
;
155 static int hash_recvmsg(struct kiocb
*unused
, struct socket
*sock
,
156 struct msghdr
*msg
, size_t len
, int flags
)
158 struct sock
*sk
= sock
->sk
;
159 struct alg_sock
*ask
= alg_sk(sk
);
160 struct hash_ctx
*ctx
= ask
->private;
161 unsigned ds
= crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
));
167 msg
->msg_flags
|= MSG_TRUNC
;
172 ahash_request_set_crypt(&ctx
->req
, NULL
, ctx
->result
, 0);
173 err
= af_alg_wait_for_completion(crypto_ahash_final(&ctx
->req
),
179 err
= memcpy_toiovec(msg
->msg_iov
, ctx
->result
, len
);
187 static int hash_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
189 struct sock
*sk
= sock
->sk
;
190 struct alg_sock
*ask
= alg_sk(sk
);
191 struct hash_ctx
*ctx
= ask
->private;
192 struct ahash_request
*req
= &ctx
->req
;
193 char state
[crypto_ahash_statesize(crypto_ahash_reqtfm(req
))];
195 struct alg_sock
*ask2
;
196 struct hash_ctx
*ctx2
;
202 err
= more
? crypto_ahash_export(req
, state
) : 0;
208 err
= af_alg_accept(ask
->parent
, newsock
);
214 ctx2
= ask2
->private;
220 err
= crypto_ahash_import(&ctx2
->req
, state
);
229 static struct proto_ops algif_hash_ops
= {
232 .connect
= sock_no_connect
,
233 .socketpair
= sock_no_socketpair
,
234 .getname
= sock_no_getname
,
235 .ioctl
= sock_no_ioctl
,
236 .listen
= sock_no_listen
,
237 .shutdown
= sock_no_shutdown
,
238 .getsockopt
= sock_no_getsockopt
,
239 .mmap
= sock_no_mmap
,
240 .bind
= sock_no_bind
,
241 .setsockopt
= sock_no_setsockopt
,
242 .poll
= sock_no_poll
,
244 .release
= af_alg_release
,
245 .sendmsg
= hash_sendmsg
,
246 .sendpage
= hash_sendpage
,
247 .recvmsg
= hash_recvmsg
,
248 .accept
= hash_accept
,
251 static void *hash_bind(const char *name
, u32 type
, u32 mask
)
253 return crypto_alloc_ahash(name
, type
, mask
);
256 static void hash_release(void *private)
258 crypto_free_ahash(private);
261 static int hash_setkey(void *private, const u8
*key
, unsigned int keylen
)
263 return crypto_ahash_setkey(private, key
, keylen
);
266 static void hash_sock_destruct(struct sock
*sk
)
268 struct alg_sock
*ask
= alg_sk(sk
);
269 struct hash_ctx
*ctx
= ask
->private;
271 sock_kfree_s(sk
, ctx
->result
,
272 crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
)));
273 sock_kfree_s(sk
, ctx
, ctx
->len
);
274 af_alg_release_parent(sk
);
277 static int hash_accept_parent(void *private, struct sock
*sk
)
279 struct hash_ctx
*ctx
;
280 struct alg_sock
*ask
= alg_sk(sk
);
281 unsigned len
= sizeof(*ctx
) + crypto_ahash_reqsize(private);
282 unsigned ds
= crypto_ahash_digestsize(private);
284 ctx
= sock_kmalloc(sk
, len
, GFP_KERNEL
);
288 ctx
->result
= sock_kmalloc(sk
, ds
, GFP_KERNEL
);
290 sock_kfree_s(sk
, ctx
, len
);
294 memset(ctx
->result
, 0, ds
);
298 af_alg_init_completion(&ctx
->completion
);
302 ahash_request_set_tfm(&ctx
->req
, private);
303 ahash_request_set_callback(&ctx
->req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
304 af_alg_complete
, &ctx
->completion
);
306 sk
->sk_destruct
= hash_sock_destruct
;
311 static const struct af_alg_type algif_type_hash
= {
313 .release
= hash_release
,
314 .setkey
= hash_setkey
,
315 .accept
= hash_accept_parent
,
316 .ops
= &algif_hash_ops
,
321 static int __init
algif_hash_init(void)
323 return af_alg_register_type(&algif_type_hash
);
326 static void __exit
algif_hash_exit(void)
328 int err
= af_alg_unregister_type(&algif_type_hash
);
332 module_init(algif_hash_init
);
333 module_exit(algif_hash_exit
);
334 MODULE_LICENSE("GPL");