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
;
75 /* Allocate cipher request for current operation. */
76 areq
= af_alg_alloc_areq(sk
, sizeof(struct af_alg_async_req
) +
77 crypto_skcipher_reqsize(tfm
));
81 /* convert iovecs of output buffers into RX SGL */
82 err
= af_alg_get_rsgl(sk
, msg
, flags
, areq
, -1, &len
);
86 /* Process only as much RX buffers for which we have TX data */
91 * If more buffers are to be expected to be processed, process only
92 * full block size buffers.
94 if (ctx
->more
|| len
< ctx
->used
)
98 * Create a per request TX SGL for this request which tracks the
99 * SG entries from the global TX SGL.
101 areq
->tsgl_entries
= af_alg_count_tsgl(sk
, len
, 0);
102 if (!areq
->tsgl_entries
)
103 areq
->tsgl_entries
= 1;
104 areq
->tsgl
= sock_kmalloc(sk
, sizeof(*areq
->tsgl
) * areq
->tsgl_entries
,
110 sg_init_table(areq
->tsgl
, areq
->tsgl_entries
);
111 af_alg_pull_tsgl(sk
, len
, areq
->tsgl
, 0);
113 /* Initialize the crypto operation */
114 skcipher_request_set_tfm(&areq
->cra_u
.skcipher_req
, tfm
);
115 skcipher_request_set_crypt(&areq
->cra_u
.skcipher_req
, areq
->tsgl
,
116 areq
->first_rsgl
.sgl
.sg
, len
, ctx
->iv
);
118 if (msg
->msg_iocb
&& !is_sync_kiocb(msg
->msg_iocb
)) {
120 areq
->iocb
= msg
->msg_iocb
;
121 skcipher_request_set_callback(&areq
->cra_u
.skcipher_req
,
122 CRYPTO_TFM_REQ_MAY_SLEEP
,
123 af_alg_async_cb
, areq
);
125 crypto_skcipher_encrypt(&areq
->cra_u
.skcipher_req
) :
126 crypto_skcipher_decrypt(&areq
->cra_u
.skcipher_req
);
128 /* Synchronous operation */
129 skcipher_request_set_callback(&areq
->cra_u
.skcipher_req
,
130 CRYPTO_TFM_REQ_MAY_SLEEP
|
131 CRYPTO_TFM_REQ_MAY_BACKLOG
,
132 crypto_req_done
, &ctx
->wait
);
133 err
= crypto_wait_req(ctx
->enc
?
134 crypto_skcipher_encrypt(&areq
->cra_u
.skcipher_req
) :
135 crypto_skcipher_decrypt(&areq
->cra_u
.skcipher_req
),
139 /* AIO operation in progress */
140 if (err
== -EINPROGRESS
) {
143 /* Remember output size that will be generated. */
150 af_alg_free_areq_sgls(areq
);
151 sock_kfree_s(sk
, areq
, areq
->areqlen
);
153 return err
? err
: len
;
156 static int skcipher_recvmsg(struct socket
*sock
, struct msghdr
*msg
,
157 size_t ignored
, int flags
)
159 struct sock
*sk
= sock
->sk
;
163 while (msg_data_left(msg
)) {
164 int err
= _skcipher_recvmsg(sock
, msg
, ignored
, flags
);
167 * This error covers -EIOCBQUEUED which implies that we can
168 * only handle one AIO request. If the caller wants to have
169 * multiple AIO requests in parallel, he must make multiple
170 * separate AIO calls.
172 * Also return the error if no data has been processed so far.
175 if (err
== -EIOCBQUEUED
|| !ret
)
184 af_alg_wmem_wakeup(sk
);
190 static struct proto_ops algif_skcipher_ops
= {
193 .connect
= sock_no_connect
,
194 .socketpair
= sock_no_socketpair
,
195 .getname
= sock_no_getname
,
196 .ioctl
= sock_no_ioctl
,
197 .listen
= sock_no_listen
,
198 .shutdown
= sock_no_shutdown
,
199 .getsockopt
= sock_no_getsockopt
,
200 .mmap
= sock_no_mmap
,
201 .bind
= sock_no_bind
,
202 .accept
= sock_no_accept
,
203 .setsockopt
= sock_no_setsockopt
,
205 .release
= af_alg_release
,
206 .sendmsg
= skcipher_sendmsg
,
207 .sendpage
= af_alg_sendpage
,
208 .recvmsg
= skcipher_recvmsg
,
212 static int skcipher_check_key(struct socket
*sock
)
216 struct alg_sock
*pask
;
217 struct skcipher_tfm
*tfm
;
218 struct sock
*sk
= sock
->sk
;
219 struct alg_sock
*ask
= alg_sk(sk
);
226 pask
= alg_sk(ask
->parent
);
230 lock_sock_nested(psk
, SINGLE_DEPTH_NESTING
);
250 static int skcipher_sendmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
255 err
= skcipher_check_key(sock
);
259 return skcipher_sendmsg(sock
, msg
, size
);
262 static ssize_t
skcipher_sendpage_nokey(struct socket
*sock
, struct page
*page
,
263 int offset
, size_t size
, int flags
)
267 err
= skcipher_check_key(sock
);
271 return af_alg_sendpage(sock
, page
, offset
, size
, flags
);
274 static int skcipher_recvmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
275 size_t ignored
, int flags
)
279 err
= skcipher_check_key(sock
);
283 return skcipher_recvmsg(sock
, msg
, ignored
, flags
);
286 static struct proto_ops algif_skcipher_ops_nokey
= {
289 .connect
= sock_no_connect
,
290 .socketpair
= sock_no_socketpair
,
291 .getname
= sock_no_getname
,
292 .ioctl
= sock_no_ioctl
,
293 .listen
= sock_no_listen
,
294 .shutdown
= sock_no_shutdown
,
295 .getsockopt
= sock_no_getsockopt
,
296 .mmap
= sock_no_mmap
,
297 .bind
= sock_no_bind
,
298 .accept
= sock_no_accept
,
299 .setsockopt
= sock_no_setsockopt
,
301 .release
= af_alg_release
,
302 .sendmsg
= skcipher_sendmsg_nokey
,
303 .sendpage
= skcipher_sendpage_nokey
,
304 .recvmsg
= skcipher_recvmsg_nokey
,
308 static void *skcipher_bind(const char *name
, u32 type
, u32 mask
)
310 struct skcipher_tfm
*tfm
;
311 struct crypto_skcipher
*skcipher
;
313 tfm
= kzalloc(sizeof(*tfm
), GFP_KERNEL
);
315 return ERR_PTR(-ENOMEM
);
317 skcipher
= crypto_alloc_skcipher(name
, type
, mask
);
318 if (IS_ERR(skcipher
)) {
320 return ERR_CAST(skcipher
);
323 tfm
->skcipher
= skcipher
;
328 static void skcipher_release(void *private)
330 struct skcipher_tfm
*tfm
= private;
332 crypto_free_skcipher(tfm
->skcipher
);
336 static int skcipher_setkey(void *private, const u8
*key
, unsigned int keylen
)
338 struct skcipher_tfm
*tfm
= private;
341 err
= crypto_skcipher_setkey(tfm
->skcipher
, key
, keylen
);
347 static void skcipher_sock_destruct(struct sock
*sk
)
349 struct alg_sock
*ask
= alg_sk(sk
);
350 struct af_alg_ctx
*ctx
= ask
->private;
351 struct sock
*psk
= ask
->parent
;
352 struct alg_sock
*pask
= alg_sk(psk
);
353 struct skcipher_tfm
*skc
= pask
->private;
354 struct crypto_skcipher
*tfm
= skc
->skcipher
;
356 af_alg_pull_tsgl(sk
, ctx
->used
, NULL
, 0);
357 sock_kzfree_s(sk
, ctx
->iv
, crypto_skcipher_ivsize(tfm
));
358 sock_kfree_s(sk
, ctx
, ctx
->len
);
359 af_alg_release_parent(sk
);
362 static int skcipher_accept_parent_nokey(void *private, struct sock
*sk
)
364 struct af_alg_ctx
*ctx
;
365 struct alg_sock
*ask
= alg_sk(sk
);
366 struct skcipher_tfm
*tfm
= private;
367 struct crypto_skcipher
*skcipher
= tfm
->skcipher
;
368 unsigned int len
= sizeof(*ctx
);
370 ctx
= sock_kmalloc(sk
, len
, GFP_KERNEL
);
374 ctx
->iv
= sock_kmalloc(sk
, crypto_skcipher_ivsize(skcipher
),
377 sock_kfree_s(sk
, ctx
, len
);
381 memset(ctx
->iv
, 0, crypto_skcipher_ivsize(skcipher
));
383 INIT_LIST_HEAD(&ctx
->tsgl_list
);
390 crypto_init_wait(&ctx
->wait
);
394 sk
->sk_destruct
= skcipher_sock_destruct
;
399 static int skcipher_accept_parent(void *private, struct sock
*sk
)
401 struct skcipher_tfm
*tfm
= private;
403 if (!tfm
->has_key
&& crypto_skcipher_has_setkey(tfm
->skcipher
))
406 return skcipher_accept_parent_nokey(private, sk
);
409 static const struct af_alg_type algif_type_skcipher
= {
410 .bind
= skcipher_bind
,
411 .release
= skcipher_release
,
412 .setkey
= skcipher_setkey
,
413 .accept
= skcipher_accept_parent
,
414 .accept_nokey
= skcipher_accept_parent_nokey
,
415 .ops
= &algif_skcipher_ops
,
416 .ops_nokey
= &algif_skcipher_ops_nokey
,
421 static int __init
algif_skcipher_init(void)
423 return af_alg_register_type(&algif_type_skcipher
);
426 static void __exit
algif_skcipher_exit(void)
428 int err
= af_alg_unregister_type(&algif_type_skcipher
);
432 module_init(algif_skcipher_init
);
433 module_exit(algif_skcipher_exit
);
434 MODULE_LICENSE("GPL");