2 * algif_skcipher: User-space interface for skcipher algorithms
4 * This file provides the user-space API for symmetric key ciphers.
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)
13 * The following concept of the memory management is used:
15 * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
16 * filled by user space with the data submitted via sendpage/sendmsg. Filling
17 * up the TX SGL does not cause a crypto operation -- the data will only be
18 * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
19 * provide a buffer which is tracked with the RX SGL.
21 * During the processing of the recvmsg operation, the cipher request is
22 * allocated and prepared. As part of the recvmsg operation, the processed
23 * TX buffers are extracted from the TX SGL into a separate SGL.
25 * After the completion of the crypto operation, the RX SGL and the cipher
26 * request is released. The extracted TX SGL parts are released together with
30 #include <crypto/scatterwalk.h>
31 #include <crypto/skcipher.h>
32 #include <crypto/if_alg.h>
33 #include <linux/init.h>
34 #include <linux/list.h>
35 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/net.h>
42 struct crypto_skcipher *skcipher;
46 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
49 struct sock *sk = sock->sk;
50 struct alg_sock *ask = alg_sk(sk);
51 struct sock *psk = ask->parent;
52 struct alg_sock *pask = alg_sk(psk);
53 struct skcipher_tfm *skc = pask->private;
54 struct crypto_skcipher *tfm = skc->skcipher;
55 unsigned ivsize = crypto_skcipher_ivsize(tfm);
57 return af_alg_sendmsg(sock, msg, size, ivsize);
60 static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
61 size_t ignored, int flags)
63 struct sock *sk = sock->sk;
64 struct alg_sock *ask = alg_sk(sk);
65 struct sock *psk = ask->parent;
66 struct alg_sock *pask = alg_sk(psk);
67 struct af_alg_ctx *ctx = ask->private;
68 struct skcipher_tfm *skc = pask->private;
69 struct crypto_skcipher *tfm = skc->skcipher;
70 unsigned int bs = crypto_skcipher_blocksize(tfm);
71 struct af_alg_async_req *areq;
76 err = af_alg_wait_for_data(sk, flags);
81 /* Allocate cipher request for current operation. */
82 areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
83 crypto_skcipher_reqsize(tfm));
87 /* convert iovecs of output buffers into RX SGL */
88 err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);
92 /* Process only as much RX buffers for which we have TX data */
97 * If more buffers are to be expected to be processed, process only
98 * full block size buffers.
100 if (ctx->more || len < ctx->used)
104 * Create a per request TX SGL for this request which tracks the
105 * SG entries from the global TX SGL.
107 areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
108 if (!areq->tsgl_entries)
109 areq->tsgl_entries = 1;
110 areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries,
116 sg_init_table(areq->tsgl, areq->tsgl_entries);
117 af_alg_pull_tsgl(sk, len, areq->tsgl, 0);
119 /* Initialize the crypto operation */
120 skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm);
121 skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl,
122 areq->first_rsgl.sgl.sg, len, ctx->iv);
124 if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
127 areq->iocb = msg->msg_iocb;
129 /* Remember output size that will be generated. */
132 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
133 CRYPTO_TFM_REQ_MAY_SLEEP,
134 af_alg_async_cb, areq);
136 crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
137 crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
139 /* AIO operation in progress */
140 if (err == -EINPROGRESS || err == -EBUSY)
145 /* Synchronous operation */
146 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
147 CRYPTO_TFM_REQ_MAY_SLEEP |
148 CRYPTO_TFM_REQ_MAY_BACKLOG,
149 crypto_req_done, &ctx->wait);
150 err = crypto_wait_req(ctx->enc ?
151 crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
152 crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
158 af_alg_free_resources(areq);
160 return err ? err : len;
163 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
164 size_t ignored, int flags)
166 struct sock *sk = sock->sk;
170 while (msg_data_left(msg)) {
171 int err = _skcipher_recvmsg(sock, msg, ignored, flags);
174 * This error covers -EIOCBQUEUED which implies that we can
175 * only handle one AIO request. If the caller wants to have
176 * multiple AIO requests in parallel, he must make multiple
177 * separate AIO calls.
179 * Also return the error if no data has been processed so far.
182 if (err == -EIOCBQUEUED || !ret)
191 af_alg_wmem_wakeup(sk);
197 static struct proto_ops algif_skcipher_ops = {
200 .connect = sock_no_connect,
201 .socketpair = sock_no_socketpair,
202 .getname = sock_no_getname,
203 .ioctl = sock_no_ioctl,
204 .listen = sock_no_listen,
205 .shutdown = sock_no_shutdown,
206 .getsockopt = sock_no_getsockopt,
207 .mmap = sock_no_mmap,
208 .bind = sock_no_bind,
209 .accept = sock_no_accept,
210 .setsockopt = sock_no_setsockopt,
212 .release = af_alg_release,
213 .sendmsg = skcipher_sendmsg,
214 .sendpage = af_alg_sendpage,
215 .recvmsg = skcipher_recvmsg,
219 static int skcipher_check_key(struct socket *sock)
223 struct alg_sock *pask;
224 struct skcipher_tfm *tfm;
225 struct sock *sk = sock->sk;
226 struct alg_sock *ask = alg_sk(sk);
233 pask = alg_sk(ask->parent);
237 lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
257 static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
262 err = skcipher_check_key(sock);
266 return skcipher_sendmsg(sock, msg, size);
269 static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
270 int offset, size_t size, int flags)
274 err = skcipher_check_key(sock);
278 return af_alg_sendpage(sock, page, offset, size, flags);
281 static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
282 size_t ignored, int flags)
286 err = skcipher_check_key(sock);
290 return skcipher_recvmsg(sock, msg, ignored, flags);
293 static struct proto_ops algif_skcipher_ops_nokey = {
296 .connect = sock_no_connect,
297 .socketpair = sock_no_socketpair,
298 .getname = sock_no_getname,
299 .ioctl = sock_no_ioctl,
300 .listen = sock_no_listen,
301 .shutdown = sock_no_shutdown,
302 .getsockopt = sock_no_getsockopt,
303 .mmap = sock_no_mmap,
304 .bind = sock_no_bind,
305 .accept = sock_no_accept,
306 .setsockopt = sock_no_setsockopt,
308 .release = af_alg_release,
309 .sendmsg = skcipher_sendmsg_nokey,
310 .sendpage = skcipher_sendpage_nokey,
311 .recvmsg = skcipher_recvmsg_nokey,
315 static void *skcipher_bind(const char *name, u32 type, u32 mask)
317 struct skcipher_tfm *tfm;
318 struct crypto_skcipher *skcipher;
320 tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
322 return ERR_PTR(-ENOMEM);
324 skcipher = crypto_alloc_skcipher(name, type, mask);
325 if (IS_ERR(skcipher)) {
327 return ERR_CAST(skcipher);
330 tfm->skcipher = skcipher;
335 static void skcipher_release(void *private)
337 struct skcipher_tfm *tfm = private;
339 crypto_free_skcipher(tfm->skcipher);
343 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
345 struct skcipher_tfm *tfm = private;
348 err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
354 static void skcipher_sock_destruct(struct sock *sk)
356 struct alg_sock *ask = alg_sk(sk);
357 struct af_alg_ctx *ctx = ask->private;
358 struct sock *psk = ask->parent;
359 struct alg_sock *pask = alg_sk(psk);
360 struct skcipher_tfm *skc = pask->private;
361 struct crypto_skcipher *tfm = skc->skcipher;
363 af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
364 sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
365 sock_kfree_s(sk, ctx, ctx->len);
366 af_alg_release_parent(sk);
369 static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
371 struct af_alg_ctx *ctx;
372 struct alg_sock *ask = alg_sk(sk);
373 struct skcipher_tfm *tfm = private;
374 struct crypto_skcipher *skcipher = tfm->skcipher;
375 unsigned int len = sizeof(*ctx);
377 ctx = sock_kmalloc(sk, len, GFP_KERNEL);
381 ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
384 sock_kfree_s(sk, ctx, len);
388 memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));
390 INIT_LIST_HEAD(&ctx->tsgl_list);
393 atomic_set(&ctx->rcvused, 0);
397 crypto_init_wait(&ctx->wait);
401 sk->sk_destruct = skcipher_sock_destruct;
406 static int skcipher_accept_parent(void *private, struct sock *sk)
408 struct skcipher_tfm *tfm = private;
410 if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
413 return skcipher_accept_parent_nokey(private, sk);
416 static const struct af_alg_type algif_type_skcipher = {
417 .bind = skcipher_bind,
418 .release = skcipher_release,
419 .setkey = skcipher_setkey,
420 .accept = skcipher_accept_parent,
421 .accept_nokey = skcipher_accept_parent_nokey,
422 .ops = &algif_skcipher_ops,
423 .ops_nokey = &algif_skcipher_ops_nokey,
428 static int __init algif_skcipher_init(void)
430 return af_alg_register_type(&algif_type_skcipher);
433 static void __exit algif_skcipher_exit(void)
435 int err = af_alg_unregister_type(&algif_type_skcipher);
439 module_init(algif_skcipher_init);
440 module_exit(algif_skcipher_exit);
441 MODULE_LICENSE("GPL");