1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * algif_hash: User-space interface for hash algorithms
5 * This file provides the user-space API for hash algorithms.
7 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
10 #include <crypto/hash.h>
11 #include <crypto/if_alg.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/net.h>
20 struct af_alg_sgl sgl
;
24 struct crypto_wait wait
;
29 struct ahash_request req
;
32 static int hash_alloc_result(struct sock
*sk
, struct hash_ctx
*ctx
)
39 ds
= crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
));
41 ctx
->result
= sock_kmalloc(sk
, ds
, GFP_KERNEL
);
45 memset(ctx
->result
, 0, ds
);
50 static void hash_free_result(struct sock
*sk
, struct hash_ctx
*ctx
)
57 ds
= crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
));
59 sock_kzfree_s(sk
, ctx
->result
, ds
);
63 static int hash_sendmsg(struct socket
*sock
, struct msghdr
*msg
,
66 struct sock
*sk
= sock
->sk
;
67 struct alg_sock
*ask
= alg_sk(sk
);
68 struct hash_ctx
*ctx
= ask
->private;
70 size_t len
, max_pages
, npages
;
71 bool continuing
, need_init
= false;
74 max_pages
= min_t(size_t, ALG_MAX_PAGES
,
75 DIV_ROUND_UP(sk
->sk_sndbuf
, PAGE_SIZE
));
78 continuing
= ctx
->more
;
81 /* Discard a previous request that wasn't marked MSG_MORE. */
82 hash_free_result(sk
, ctx
);
83 if (!msg_data_left(msg
))
84 goto done
; /* Zero-length; don't start new req */
86 } else if (!msg_data_left(msg
)) {
88 * No data - finalise the prev req if MSG_MORE so any error
91 if (!(msg
->msg_flags
& MSG_MORE
)) {
92 err
= hash_alloc_result(sk
, ctx
);
95 ahash_request_set_crypt(&ctx
->req
, NULL
,
97 err
= crypto_wait_req(crypto_ahash_final(&ctx
->req
),
105 while (msg_data_left(msg
)) {
106 ctx
->sgl
.sgt
.sgl
= ctx
->sgl
.sgl
;
107 ctx
->sgl
.sgt
.nents
= 0;
108 ctx
->sgl
.sgt
.orig_nents
= 0;
111 npages
= iov_iter_npages(&msg
->msg_iter
, max_pages
);
115 sg_init_table(ctx
->sgl
.sgl
, npages
);
117 ctx
->sgl
.need_unpin
= iov_iter_extract_will_pin(&msg
->msg_iter
);
119 err
= extract_iter_to_sg(&msg
->msg_iter
, LONG_MAX
,
120 &ctx
->sgl
.sgt
, npages
, 0);
124 sg_mark_end(ctx
->sgl
.sgt
.sgl
+ ctx
->sgl
.sgt
.nents
- 1);
126 if (!msg_data_left(msg
)) {
127 err
= hash_alloc_result(sk
, ctx
);
132 ahash_request_set_crypt(&ctx
->req
, ctx
->sgl
.sgt
.sgl
,
135 if (!msg_data_left(msg
) && !continuing
&&
136 !(msg
->msg_flags
& MSG_MORE
)) {
137 err
= crypto_ahash_digest(&ctx
->req
);
140 err
= crypto_wait_req(
141 crypto_ahash_init(&ctx
->req
),
148 if (msg_data_left(msg
) || (msg
->msg_flags
& MSG_MORE
))
149 err
= crypto_ahash_update(&ctx
->req
);
151 err
= crypto_ahash_finup(&ctx
->req
);
155 err
= crypto_wait_req(err
, &ctx
->wait
);
160 af_alg_free_sg(&ctx
->sgl
);
164 ctx
->more
= msg
->msg_flags
& MSG_MORE
;
169 return copied
?: err
;
172 af_alg_free_sg(&ctx
->sgl
);
173 hash_free_result(sk
, ctx
);
178 static int hash_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
,
181 struct sock
*sk
= sock
->sk
;
182 struct alg_sock
*ask
= alg_sk(sk
);
183 struct hash_ctx
*ctx
= ask
->private;
184 unsigned ds
= crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx
->req
));
191 msg
->msg_flags
|= MSG_TRUNC
;
194 result
= ctx
->result
;
195 err
= hash_alloc_result(sk
, ctx
);
199 ahash_request_set_crypt(&ctx
->req
, NULL
, ctx
->result
, 0);
201 if (!result
&& !ctx
->more
) {
202 err
= crypto_wait_req(crypto_ahash_init(&ctx
->req
),
208 if (!result
|| ctx
->more
) {
210 err
= crypto_wait_req(crypto_ahash_final(&ctx
->req
),
216 err
= memcpy_to_msg(msg
, ctx
->result
, len
);
219 hash_free_result(sk
, ctx
);
225 static int hash_accept(struct socket
*sock
, struct socket
*newsock
, int flags
,
228 struct sock
*sk
= sock
->sk
;
229 struct alg_sock
*ask
= alg_sk(sk
);
230 struct hash_ctx
*ctx
= ask
->private;
231 struct ahash_request
*req
= &ctx
->req
;
232 struct crypto_ahash
*tfm
;
234 struct alg_sock
*ask2
;
235 struct hash_ctx
*ctx2
;
240 tfm
= crypto_ahash_reqtfm(req
);
241 state
= kmalloc(crypto_ahash_statesize(tfm
), GFP_KERNEL
);
248 err
= more
? crypto_ahash_export(req
, state
) : 0;
254 err
= af_alg_accept(ask
->parent
, newsock
, kern
);
260 ctx2
= ask2
->private;
266 err
= crypto_ahash_import(&ctx2
->req
, state
);
273 kfree_sensitive(state
);
279 static struct proto_ops algif_hash_ops
= {
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 .mmap
= sock_no_mmap
,
289 .bind
= sock_no_bind
,
291 .release
= af_alg_release
,
292 .sendmsg
= hash_sendmsg
,
293 .recvmsg
= hash_recvmsg
,
294 .accept
= hash_accept
,
297 static int hash_check_key(struct socket
*sock
)
301 struct alg_sock
*pask
;
302 struct crypto_ahash
*tfm
;
303 struct sock
*sk
= sock
->sk
;
304 struct alg_sock
*ask
= alg_sk(sk
);
307 if (!atomic_read(&ask
->nokey_refcnt
))
311 pask
= alg_sk(ask
->parent
);
315 lock_sock_nested(psk
, SINGLE_DEPTH_NESTING
);
316 if (crypto_ahash_get_flags(tfm
) & CRYPTO_TFM_NEED_KEY
)
319 atomic_dec(&pask
->nokey_refcnt
);
320 atomic_set(&ask
->nokey_refcnt
, 0);
332 static int hash_sendmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
337 err
= hash_check_key(sock
);
341 return hash_sendmsg(sock
, msg
, size
);
344 static int hash_recvmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
345 size_t ignored
, int flags
)
349 err
= hash_check_key(sock
);
353 return hash_recvmsg(sock
, msg
, ignored
, flags
);
356 static int hash_accept_nokey(struct socket
*sock
, struct socket
*newsock
,
357 int flags
, bool kern
)
361 err
= hash_check_key(sock
);
365 return hash_accept(sock
, newsock
, flags
, kern
);
368 static struct proto_ops algif_hash_ops_nokey
= {
371 .connect
= sock_no_connect
,
372 .socketpair
= sock_no_socketpair
,
373 .getname
= sock_no_getname
,
374 .ioctl
= sock_no_ioctl
,
375 .listen
= sock_no_listen
,
376 .shutdown
= sock_no_shutdown
,
377 .mmap
= sock_no_mmap
,
378 .bind
= sock_no_bind
,
380 .release
= af_alg_release
,
381 .sendmsg
= hash_sendmsg_nokey
,
382 .recvmsg
= hash_recvmsg_nokey
,
383 .accept
= hash_accept_nokey
,
386 static void *hash_bind(const char *name
, u32 type
, u32 mask
)
388 return crypto_alloc_ahash(name
, type
, mask
);
391 static void hash_release(void *private)
393 crypto_free_ahash(private);
396 static int hash_setkey(void *private, const u8
*key
, unsigned int keylen
)
398 return crypto_ahash_setkey(private, key
, keylen
);
401 static void hash_sock_destruct(struct sock
*sk
)
403 struct alg_sock
*ask
= alg_sk(sk
);
404 struct hash_ctx
*ctx
= ask
->private;
406 hash_free_result(sk
, ctx
);
407 sock_kfree_s(sk
, ctx
, ctx
->len
);
408 af_alg_release_parent(sk
);
411 static int hash_accept_parent_nokey(void *private, struct sock
*sk
)
413 struct crypto_ahash
*tfm
= private;
414 struct alg_sock
*ask
= alg_sk(sk
);
415 struct hash_ctx
*ctx
;
416 unsigned int len
= sizeof(*ctx
) + crypto_ahash_reqsize(tfm
);
418 ctx
= sock_kmalloc(sk
, len
, GFP_KERNEL
);
425 crypto_init_wait(&ctx
->wait
);
429 ahash_request_set_tfm(&ctx
->req
, tfm
);
430 ahash_request_set_callback(&ctx
->req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
431 crypto_req_done
, &ctx
->wait
);
433 sk
->sk_destruct
= hash_sock_destruct
;
438 static int hash_accept_parent(void *private, struct sock
*sk
)
440 struct crypto_ahash
*tfm
= private;
442 if (crypto_ahash_get_flags(tfm
) & CRYPTO_TFM_NEED_KEY
)
445 return hash_accept_parent_nokey(private, sk
);
448 static const struct af_alg_type algif_type_hash
= {
450 .release
= hash_release
,
451 .setkey
= hash_setkey
,
452 .accept
= hash_accept_parent
,
453 .accept_nokey
= hash_accept_parent_nokey
,
454 .ops
= &algif_hash_ops
,
455 .ops_nokey
= &algif_hash_ops_nokey
,
460 static int __init
algif_hash_init(void)
462 return af_alg_register_type(&algif_type_hash
);
465 static void __exit
algif_hash_exit(void)
467 int err
= af_alg_unregister_type(&algif_type_hash
);
471 module_init(algif_hash_init
);
472 module_exit(algif_hash_exit
);
473 MODULE_LICENSE("GPL");