1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * algif_skcipher: User-space interface for skcipher algorithms
5 * This file provides the user-space API for symmetric key ciphers.
7 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
9 * The following concept of the memory management is used:
11 * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
12 * filled by user space with the data submitted via sendpage/sendmsg. Filling
13 * up the TX SGL does not cause a crypto operation -- the data will only be
14 * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
15 * provide a buffer which is tracked with the RX SGL.
17 * During the processing of the recvmsg operation, the cipher request is
18 * allocated and prepared. As part of the recvmsg operation, the processed
19 * TX buffers are extracted from the TX SGL into a separate SGL.
21 * After the completion of the crypto operation, the RX SGL and the cipher
22 * request is released. The extracted TX SGL parts are released together with
26 #include <crypto/scatterwalk.h>
27 #include <crypto/skcipher.h>
28 #include <crypto/if_alg.h>
29 #include <linux/init.h>
30 #include <linux/list.h>
31 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/net.h>
37 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
40 struct sock *sk = sock->sk;
41 struct alg_sock *ask = alg_sk(sk);
42 struct sock *psk = ask->parent;
43 struct alg_sock *pask = alg_sk(psk);
44 struct crypto_skcipher *tfm = pask->private;
45 unsigned ivsize = crypto_skcipher_ivsize(tfm);
47 return af_alg_sendmsg(sock, msg, size, ivsize);
50 static inline int skcipher_cipher_op(struct af_alg_ctx *ctx,
51 struct af_alg_async_req *areq)
55 return crypto_skcipher_encrypt(&areq->cra_u.skcipher_req);
57 return crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
63 static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
64 size_t ignored, int flags)
66 struct sock *sk = sock->sk;
67 struct alg_sock *ask = alg_sk(sk);
68 struct sock *psk = ask->parent;
69 struct alg_sock *pask = alg_sk(psk);
70 struct af_alg_ctx *ctx = ask->private;
71 struct crypto_skcipher *tfm = pask->private;
72 unsigned int bs = crypto_skcipher_chunksize(tfm);
73 struct af_alg_async_req *areq;
77 if (!ctx->init || (ctx->more && ctx->used < bs)) {
78 err = af_alg_wait_for_data(sk, flags, bs);
83 /* Allocate cipher request for current operation. */
84 areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
85 crypto_skcipher_reqsize(tfm));
89 /* convert iovecs of output buffers into RX SGL */
90 err = af_alg_get_rsgl(sk, msg, flags, areq, ctx->used, &len);
95 * If more buffers are to be expected to be processed, process only
96 * full block size buffers.
98 if (ctx->more || len < ctx->used)
102 * Create a per request TX SGL for this request which tracks the
103 * SG entries from the global TX SGL.
105 areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
106 if (!areq->tsgl_entries)
107 areq->tsgl_entries = 1;
108 areq->tsgl = sock_kmalloc(sk, array_size(sizeof(*areq->tsgl),
115 sg_init_table(areq->tsgl, areq->tsgl_entries);
116 af_alg_pull_tsgl(sk, len, areq->tsgl, 0);
118 /* Initialize the crypto operation */
119 skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm);
120 skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl,
121 areq->first_rsgl.sgl.sg, len, ctx->iv);
123 if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
126 areq->iocb = msg->msg_iocb;
128 /* Remember output size that will be generated. */
131 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
132 CRYPTO_TFM_REQ_MAY_SLEEP,
133 af_alg_async_cb, areq);
134 err = skcipher_cipher_op(ctx, areq);
136 /* AIO operation in progress */
137 if (err == -EINPROGRESS)
142 /* Synchronous operation */
143 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
144 CRYPTO_TFM_REQ_MAY_SLEEP |
145 CRYPTO_TFM_REQ_MAY_BACKLOG,
146 crypto_req_done, &ctx->wait);
147 err = crypto_wait_req(skcipher_cipher_op(ctx, areq),
153 af_alg_free_resources(areq);
155 return err ? err : len;
158 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
159 size_t ignored, int flags)
161 struct sock *sk = sock->sk;
165 while (msg_data_left(msg)) {
166 int err = _skcipher_recvmsg(sock, msg, ignored, flags);
169 * This error covers -EIOCBQUEUED which implies that we can
170 * only handle one AIO request. If the caller wants to have
171 * multiple AIO requests in parallel, he must make multiple
172 * separate AIO calls.
174 * Also return the error if no data has been processed so far.
177 if (err == -EIOCBQUEUED || !ret)
186 af_alg_wmem_wakeup(sk);
191 static struct proto_ops algif_skcipher_ops = {
194 .connect = sock_no_connect,
195 .socketpair = sock_no_socketpair,
196 .getname = sock_no_getname,
197 .ioctl = sock_no_ioctl,
198 .listen = sock_no_listen,
199 .shutdown = sock_no_shutdown,
200 .mmap = sock_no_mmap,
201 .bind = sock_no_bind,
202 .accept = sock_no_accept,
204 .release = af_alg_release,
205 .sendmsg = skcipher_sendmsg,
206 .sendpage = af_alg_sendpage,
207 .recvmsg = skcipher_recvmsg,
211 static int skcipher_check_key(struct socket *sock)
215 struct alg_sock *pask;
216 struct crypto_skcipher *tfm;
217 struct sock *sk = sock->sk;
218 struct alg_sock *ask = alg_sk(sk);
221 if (!atomic_read(&ask->nokey_refcnt))
225 pask = alg_sk(ask->parent);
229 lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
230 if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
233 atomic_dec(&pask->nokey_refcnt);
234 atomic_set(&ask->nokey_refcnt, 0);
246 static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
251 err = skcipher_check_key(sock);
255 return skcipher_sendmsg(sock, msg, size);
258 static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
259 int offset, size_t size, int flags)
263 err = skcipher_check_key(sock);
267 return af_alg_sendpage(sock, page, offset, size, flags);
270 static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
271 size_t ignored, int flags)
275 err = skcipher_check_key(sock);
279 return skcipher_recvmsg(sock, msg, ignored, flags);
282 static struct proto_ops algif_skcipher_ops_nokey = {
285 .connect = sock_no_connect,
286 .socketpair = sock_no_socketpair,
287 .getname = sock_no_getname,
288 .ioctl = sock_no_ioctl,
289 .listen = sock_no_listen,
290 .shutdown = sock_no_shutdown,
291 .mmap = sock_no_mmap,
292 .bind = sock_no_bind,
293 .accept = sock_no_accept,
295 .release = af_alg_release,
296 .sendmsg = skcipher_sendmsg_nokey,
297 .sendpage = skcipher_sendpage_nokey,
298 .recvmsg = skcipher_recvmsg_nokey,
302 static void *skcipher_bind(const char *name, u32 type, u32 mask)
304 return crypto_alloc_skcipher(name, type, mask);
307 static void skcipher_release(void *private)
309 crypto_free_skcipher(private);
312 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
314 return crypto_skcipher_setkey(private, key, keylen);
317 static void skcipher_sock_destruct(struct sock *sk)
319 struct alg_sock *ask = alg_sk(sk);
320 struct af_alg_ctx *ctx = ask->private;
321 struct sock *psk = ask->parent;
322 struct alg_sock *pask = alg_sk(psk);
323 struct crypto_skcipher *tfm = pask->private;
325 af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
326 sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
327 sock_kfree_s(sk, ctx, ctx->len);
328 af_alg_release_parent(sk);
331 static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
333 struct af_alg_ctx *ctx;
334 struct alg_sock *ask = alg_sk(sk);
335 struct crypto_skcipher *tfm = private;
336 unsigned int len = sizeof(*ctx);
338 ctx = sock_kmalloc(sk, len, GFP_KERNEL);
343 ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(tfm),
346 sock_kfree_s(sk, ctx, len);
349 memset(ctx->iv, 0, crypto_skcipher_ivsize(tfm));
351 INIT_LIST_HEAD(&ctx->tsgl_list);
353 crypto_init_wait(&ctx->wait);
357 sk->sk_destruct = skcipher_sock_destruct;
362 static int skcipher_accept_parent(void *private, struct sock *sk)
364 struct crypto_skcipher *tfm = private;
366 if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
369 return skcipher_accept_parent_nokey(private, sk);
372 static const struct af_alg_type algif_type_skcipher = {
373 .bind = skcipher_bind,
374 .release = skcipher_release,
375 .setkey = skcipher_setkey,
376 .accept = skcipher_accept_parent,
377 .accept_nokey = skcipher_accept_parent_nokey,
378 .ops = &algif_skcipher_ops,
379 .ops_nokey = &algif_skcipher_ops_nokey,
384 static int __init algif_skcipher_init(void)
386 return af_alg_register_type(&algif_type_skcipher);
389 static void __exit algif_skcipher_exit(void)
391 int err = af_alg_unregister_type(&algif_type_skcipher);
395 module_init(algif_skcipher_init);
396 module_exit(algif_skcipher_exit);
397 MODULE_LICENSE("GPL");