xref: /openbmc/linux/crypto/algif_skcipher.c (revision b28fc82267aa07c34e019a72c42292d156654ee8)
18ff59090SHerbert Xu /*
28ff59090SHerbert Xu  * algif_skcipher: User-space interface for skcipher algorithms
38ff59090SHerbert Xu  *
48ff59090SHerbert Xu  * This file provides the user-space API for symmetric key ciphers.
58ff59090SHerbert Xu  *
68ff59090SHerbert Xu  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
78ff59090SHerbert Xu  *
88ff59090SHerbert Xu  * This program is free software; you can redistribute it and/or modify it
98ff59090SHerbert Xu  * under the terms of the GNU General Public License as published by the Free
108ff59090SHerbert Xu  * Software Foundation; either version 2 of the License, or (at your option)
118ff59090SHerbert Xu  * any later version.
128ff59090SHerbert Xu  *
13e870456dSStephan Mueller  * The following concept of the memory management is used:
14e870456dSStephan Mueller  *
15e870456dSStephan Mueller  * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
16e870456dSStephan Mueller  * filled by user space with the data submitted via sendpage/sendmsg. Filling
17e870456dSStephan Mueller  * up the TX SGL does not cause a crypto operation -- the data will only be
18e870456dSStephan Mueller  * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
19e870456dSStephan Mueller  * provide a buffer which is tracked with the RX SGL.
20e870456dSStephan Mueller  *
21e870456dSStephan Mueller  * During the processing of the recvmsg operation, the cipher request is
22e870456dSStephan Mueller  * allocated and prepared. As part of the recvmsg operation, the processed
23e870456dSStephan Mueller  * TX buffers are extracted from the TX SGL into a separate SGL.
24e870456dSStephan Mueller  *
25e870456dSStephan Mueller  * After the completion of the crypto operation, the RX SGL and the cipher
26e870456dSStephan Mueller  * request is released. The extracted TX SGL parts are released together with
27e870456dSStephan Mueller  * the RX SGL release.
288ff59090SHerbert Xu  */
298ff59090SHerbert Xu 
308ff59090SHerbert Xu #include <crypto/scatterwalk.h>
318ff59090SHerbert Xu #include <crypto/skcipher.h>
328ff59090SHerbert Xu #include <crypto/if_alg.h>
338ff59090SHerbert Xu #include <linux/init.h>
348ff59090SHerbert Xu #include <linux/list.h>
358ff59090SHerbert Xu #include <linux/kernel.h>
368ff59090SHerbert Xu #include <linux/mm.h>
378ff59090SHerbert Xu #include <linux/module.h>
388ff59090SHerbert Xu #include <linux/net.h>
398ff59090SHerbert Xu #include <net/sock.h>
408ff59090SHerbert Xu 
411b784140SYing Xue static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
421b784140SYing Xue 			    size_t size)
438ff59090SHerbert Xu {
448ff59090SHerbert Xu 	struct sock *sk = sock->sk;
458ff59090SHerbert Xu 	struct alg_sock *ask = alg_sk(sk);
466454c2b8SHerbert Xu 	struct sock *psk = ask->parent;
476454c2b8SHerbert Xu 	struct alg_sock *pask = alg_sk(psk);
48f8d33facSEric Biggers 	struct crypto_skcipher *tfm = pask->private;
490d96e4baSHerbert Xu 	unsigned ivsize = crypto_skcipher_ivsize(tfm);
508ff59090SHerbert Xu 
512d97591eSStephan Mueller 	return af_alg_sendmsg(sock, msg, size, ivsize);
52a596999bSTadeusz Struk }
53a596999bSTadeusz Struk 
54e870456dSStephan Mueller static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
55e870456dSStephan Mueller 			     size_t ignored, int flags)
56a596999bSTadeusz Struk {
57a596999bSTadeusz Struk 	struct sock *sk = sock->sk;
58a596999bSTadeusz Struk 	struct alg_sock *ask = alg_sk(sk);
59ec69bbfbSHerbert Xu 	struct sock *psk = ask->parent;
60ec69bbfbSHerbert Xu 	struct alg_sock *pask = alg_sk(psk);
612d97591eSStephan Mueller 	struct af_alg_ctx *ctx = ask->private;
62f8d33facSEric Biggers 	struct crypto_skcipher *tfm = pask->private;
63e870456dSStephan Mueller 	unsigned int bs = crypto_skcipher_blocksize(tfm);
642d97591eSStephan Mueller 	struct af_alg_async_req *areq;
65e870456dSStephan Mueller 	int err = 0;
66e870456dSStephan Mueller 	size_t len = 0;
67ec69bbfbSHerbert Xu 
6811edb555SStephan Mueller 	if (!ctx->used) {
6911edb555SStephan Mueller 		err = af_alg_wait_for_data(sk, flags);
7011edb555SStephan Mueller 		if (err)
7111edb555SStephan Mueller 			return err;
7211edb555SStephan Mueller 	}
7311edb555SStephan Mueller 
74e870456dSStephan Mueller 	/* Allocate cipher request for current operation. */
752d97591eSStephan Mueller 	areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
762d97591eSStephan Mueller 				     crypto_skcipher_reqsize(tfm));
772d97591eSStephan Mueller 	if (IS_ERR(areq))
782d97591eSStephan Mueller 		return PTR_ERR(areq);
79ec69bbfbSHerbert Xu 
80e870456dSStephan Mueller 	/* convert iovecs of output buffers into RX SGL */
812d97591eSStephan Mueller 	err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);
82a596999bSTadeusz Struk 	if (err)
83a596999bSTadeusz Struk 		goto free;
84a596999bSTadeusz Struk 
85e870456dSStephan Mueller 	/* Process only as much RX buffers for which we have TX data */
86e870456dSStephan Mueller 	if (len > ctx->used)
87e870456dSStephan Mueller 		len = ctx->used;
88033f46b3Stadeusz.struk@intel.com 
89e870456dSStephan Mueller 	/*
90e870456dSStephan Mueller 	 * If more buffers are to be expected to be processed, process only
91e870456dSStephan Mueller 	 * full block size buffers.
92e870456dSStephan Mueller 	 */
93e870456dSStephan Mueller 	if (ctx->more || len < ctx->used)
94e870456dSStephan Mueller 		len -= len % bs;
95a596999bSTadeusz Struk 
96e870456dSStephan Mueller 	/*
97e870456dSStephan Mueller 	 * Create a per request TX SGL for this request which tracks the
98e870456dSStephan Mueller 	 * SG entries from the global TX SGL.
99e870456dSStephan Mueller 	 */
1002d97591eSStephan Mueller 	areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
101e870456dSStephan Mueller 	if (!areq->tsgl_entries)
102e870456dSStephan Mueller 		areq->tsgl_entries = 1;
103e870456dSStephan Mueller 	areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries,
104e870456dSStephan Mueller 				  GFP_KERNEL);
105e870456dSStephan Mueller 	if (!areq->tsgl) {
106e870456dSStephan Mueller 		err = -ENOMEM;
107bc97e57eSHerbert Xu 		goto free;
108e870456dSStephan Mueller 	}
109e870456dSStephan Mueller 	sg_init_table(areq->tsgl, areq->tsgl_entries);
1102d97591eSStephan Mueller 	af_alg_pull_tsgl(sk, len, areq->tsgl, 0);
1118ff59090SHerbert Xu 
112e870456dSStephan Mueller 	/* Initialize the crypto operation */
1132d97591eSStephan Mueller 	skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm);
1142d97591eSStephan Mueller 	skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl,
1152d97591eSStephan Mueller 				   areq->first_rsgl.sgl.sg, len, ctx->iv);
1164f0414e5SHerbert Xu 
117e870456dSStephan Mueller 	if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
118e870456dSStephan Mueller 		/* AIO operation */
1197d2c3f54SStephan Mueller 		sock_hold(sk);
120e870456dSStephan Mueller 		areq->iocb = msg->msg_iocb;
121d53c5135SStephan Mueller 
122d53c5135SStephan Mueller 		/* Remember output size that will be generated. */
123d53c5135SStephan Mueller 		areq->outlen = len;
124d53c5135SStephan Mueller 
1252d97591eSStephan Mueller 		skcipher_request_set_callback(&areq->cra_u.skcipher_req,
126e870456dSStephan Mueller 					      CRYPTO_TFM_REQ_MAY_SLEEP,
1272d97591eSStephan Mueller 					      af_alg_async_cb, areq);
1282d97591eSStephan Mueller 		err = ctx->enc ?
1292d97591eSStephan Mueller 			crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
1302d97591eSStephan Mueller 			crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
1317d2c3f54SStephan Mueller 
1327d2c3f54SStephan Mueller 		/* AIO operation in progress */
133d53c5135SStephan Mueller 		if (err == -EINPROGRESS || err == -EBUSY)
1347d2c3f54SStephan Mueller 			return -EIOCBQUEUED;
1357d2c3f54SStephan Mueller 
1367d2c3f54SStephan Mueller 		sock_put(sk);
137e870456dSStephan Mueller 	} else {
138e870456dSStephan Mueller 		/* Synchronous operation */
1392d97591eSStephan Mueller 		skcipher_request_set_callback(&areq->cra_u.skcipher_req,
140e870456dSStephan Mueller 					      CRYPTO_TFM_REQ_MAY_SLEEP |
141e870456dSStephan Mueller 					      CRYPTO_TFM_REQ_MAY_BACKLOG,
1422c3f8b16SGilad Ben-Yossef 					      crypto_req_done, &ctx->wait);
1432c3f8b16SGilad Ben-Yossef 		err = crypto_wait_req(ctx->enc ?
1442d97591eSStephan Mueller 			crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
1452d97591eSStephan Mueller 			crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
1462c3f8b16SGilad Ben-Yossef 						 &ctx->wait);
1478ff59090SHerbert Xu 	}
1488ff59090SHerbert Xu 
1498ff59090SHerbert Xu 
150e870456dSStephan Mueller free:
1517d2c3f54SStephan Mueller 	af_alg_free_resources(areq);
1528ff59090SHerbert Xu 
153e870456dSStephan Mueller 	return err ? err : len;
1548ff59090SHerbert Xu }
1558ff59090SHerbert Xu 
156a596999bSTadeusz Struk static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
157a596999bSTadeusz Struk 			    size_t ignored, int flags)
158a596999bSTadeusz Struk {
159e870456dSStephan Mueller 	struct sock *sk = sock->sk;
160e870456dSStephan Mueller 	int ret = 0;
161e870456dSStephan Mueller 
162e870456dSStephan Mueller 	lock_sock(sk);
163e870456dSStephan Mueller 	while (msg_data_left(msg)) {
164e870456dSStephan Mueller 		int err = _skcipher_recvmsg(sock, msg, ignored, flags);
165e870456dSStephan Mueller 
166e870456dSStephan Mueller 		/*
167e870456dSStephan Mueller 		 * This error covers -EIOCBQUEUED which implies that we can
168e870456dSStephan Mueller 		 * only handle one AIO request. If the caller wants to have
169e870456dSStephan Mueller 		 * multiple AIO requests in parallel, he must make multiple
170e870456dSStephan Mueller 		 * separate AIO calls.
1715703c826SStephan Mueller 		 *
1725703c826SStephan Mueller 		 * Also return the error if no data has been processed so far.
173e870456dSStephan Mueller 		 */
174e870456dSStephan Mueller 		if (err <= 0) {
1755703c826SStephan Mueller 			if (err == -EIOCBQUEUED || !ret)
176e870456dSStephan Mueller 				ret = err;
177e870456dSStephan Mueller 			goto out;
178e870456dSStephan Mueller 		}
179e870456dSStephan Mueller 
180e870456dSStephan Mueller 		ret += err;
181e870456dSStephan Mueller 	}
182e870456dSStephan Mueller 
183e870456dSStephan Mueller out:
1842d97591eSStephan Mueller 	af_alg_wmem_wakeup(sk);
185e870456dSStephan Mueller 	release_sock(sk);
186e870456dSStephan Mueller 	return ret;
187a596999bSTadeusz Struk }
1888ff59090SHerbert Xu 
1898ff59090SHerbert Xu static struct proto_ops algif_skcipher_ops = {
1908ff59090SHerbert Xu 	.family		=	PF_ALG,
1918ff59090SHerbert Xu 
1928ff59090SHerbert Xu 	.connect	=	sock_no_connect,
1938ff59090SHerbert Xu 	.socketpair	=	sock_no_socketpair,
1948ff59090SHerbert Xu 	.getname	=	sock_no_getname,
1958ff59090SHerbert Xu 	.ioctl		=	sock_no_ioctl,
1968ff59090SHerbert Xu 	.listen		=	sock_no_listen,
1978ff59090SHerbert Xu 	.shutdown	=	sock_no_shutdown,
1988ff59090SHerbert Xu 	.getsockopt	=	sock_no_getsockopt,
1998ff59090SHerbert Xu 	.mmap		=	sock_no_mmap,
2008ff59090SHerbert Xu 	.bind		=	sock_no_bind,
2018ff59090SHerbert Xu 	.accept		=	sock_no_accept,
2028ff59090SHerbert Xu 	.setsockopt	=	sock_no_setsockopt,
2038ff59090SHerbert Xu 
2048ff59090SHerbert Xu 	.release	=	af_alg_release,
2058ff59090SHerbert Xu 	.sendmsg	=	skcipher_sendmsg,
2062d97591eSStephan Mueller 	.sendpage	=	af_alg_sendpage,
2078ff59090SHerbert Xu 	.recvmsg	=	skcipher_recvmsg,
208*b28fc822SChristoph Hellwig 	.poll_mask	=	af_alg_poll_mask,
2098ff59090SHerbert Xu };
2108ff59090SHerbert Xu 
211a0fa2d03SHerbert Xu static int skcipher_check_key(struct socket *sock)
212a0fa2d03SHerbert Xu {
2131822793aSHerbert Xu 	int err = 0;
214a0fa2d03SHerbert Xu 	struct sock *psk;
215a0fa2d03SHerbert Xu 	struct alg_sock *pask;
216f8d33facSEric Biggers 	struct crypto_skcipher *tfm;
217a0fa2d03SHerbert Xu 	struct sock *sk = sock->sk;
218a0fa2d03SHerbert Xu 	struct alg_sock *ask = alg_sk(sk);
219a0fa2d03SHerbert Xu 
2201822793aSHerbert Xu 	lock_sock(sk);
221a0fa2d03SHerbert Xu 	if (ask->refcnt)
2221822793aSHerbert Xu 		goto unlock_child;
223a0fa2d03SHerbert Xu 
224a0fa2d03SHerbert Xu 	psk = ask->parent;
225a0fa2d03SHerbert Xu 	pask = alg_sk(ask->parent);
226a0fa2d03SHerbert Xu 	tfm = pask->private;
227a0fa2d03SHerbert Xu 
228a0fa2d03SHerbert Xu 	err = -ENOKEY;
2291822793aSHerbert Xu 	lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
230f8d33facSEric Biggers 	if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
231a0fa2d03SHerbert Xu 		goto unlock;
232a0fa2d03SHerbert Xu 
233a0fa2d03SHerbert Xu 	if (!pask->refcnt++)
234a0fa2d03SHerbert Xu 		sock_hold(psk);
235a0fa2d03SHerbert Xu 
236a0fa2d03SHerbert Xu 	ask->refcnt = 1;
237a0fa2d03SHerbert Xu 	sock_put(psk);
238a0fa2d03SHerbert Xu 
239a0fa2d03SHerbert Xu 	err = 0;
240a0fa2d03SHerbert Xu 
241a0fa2d03SHerbert Xu unlock:
242a0fa2d03SHerbert Xu 	release_sock(psk);
2431822793aSHerbert Xu unlock_child:
2441822793aSHerbert Xu 	release_sock(sk);
245a0fa2d03SHerbert Xu 
246a0fa2d03SHerbert Xu 	return err;
247a0fa2d03SHerbert Xu }
248a0fa2d03SHerbert Xu 
249a0fa2d03SHerbert Xu static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
250a0fa2d03SHerbert Xu 				  size_t size)
251a0fa2d03SHerbert Xu {
252a0fa2d03SHerbert Xu 	int err;
253a0fa2d03SHerbert Xu 
254a0fa2d03SHerbert Xu 	err = skcipher_check_key(sock);
255a0fa2d03SHerbert Xu 	if (err)
256a0fa2d03SHerbert Xu 		return err;
257a0fa2d03SHerbert Xu 
258a0fa2d03SHerbert Xu 	return skcipher_sendmsg(sock, msg, size);
259a0fa2d03SHerbert Xu }
260a0fa2d03SHerbert Xu 
261a0fa2d03SHerbert Xu static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
262a0fa2d03SHerbert Xu 				       int offset, size_t size, int flags)
263a0fa2d03SHerbert Xu {
264a0fa2d03SHerbert Xu 	int err;
265a0fa2d03SHerbert Xu 
266a0fa2d03SHerbert Xu 	err = skcipher_check_key(sock);
267a0fa2d03SHerbert Xu 	if (err)
268a0fa2d03SHerbert Xu 		return err;
269a0fa2d03SHerbert Xu 
2702d97591eSStephan Mueller 	return af_alg_sendpage(sock, page, offset, size, flags);
271a0fa2d03SHerbert Xu }
272a0fa2d03SHerbert Xu 
273a0fa2d03SHerbert Xu static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
274a0fa2d03SHerbert Xu 				  size_t ignored, int flags)
275a0fa2d03SHerbert Xu {
276a0fa2d03SHerbert Xu 	int err;
277a0fa2d03SHerbert Xu 
278a0fa2d03SHerbert Xu 	err = skcipher_check_key(sock);
279a0fa2d03SHerbert Xu 	if (err)
280a0fa2d03SHerbert Xu 		return err;
281a0fa2d03SHerbert Xu 
282a0fa2d03SHerbert Xu 	return skcipher_recvmsg(sock, msg, ignored, flags);
283a0fa2d03SHerbert Xu }
284a0fa2d03SHerbert Xu 
285a0fa2d03SHerbert Xu static struct proto_ops algif_skcipher_ops_nokey = {
286a0fa2d03SHerbert Xu 	.family		=	PF_ALG,
287a0fa2d03SHerbert Xu 
288a0fa2d03SHerbert Xu 	.connect	=	sock_no_connect,
289a0fa2d03SHerbert Xu 	.socketpair	=	sock_no_socketpair,
290a0fa2d03SHerbert Xu 	.getname	=	sock_no_getname,
291a0fa2d03SHerbert Xu 	.ioctl		=	sock_no_ioctl,
292a0fa2d03SHerbert Xu 	.listen		=	sock_no_listen,
293a0fa2d03SHerbert Xu 	.shutdown	=	sock_no_shutdown,
294a0fa2d03SHerbert Xu 	.getsockopt	=	sock_no_getsockopt,
295a0fa2d03SHerbert Xu 	.mmap		=	sock_no_mmap,
296a0fa2d03SHerbert Xu 	.bind		=	sock_no_bind,
297a0fa2d03SHerbert Xu 	.accept		=	sock_no_accept,
298a0fa2d03SHerbert Xu 	.setsockopt	=	sock_no_setsockopt,
299a0fa2d03SHerbert Xu 
300a0fa2d03SHerbert Xu 	.release	=	af_alg_release,
301a0fa2d03SHerbert Xu 	.sendmsg	=	skcipher_sendmsg_nokey,
302a0fa2d03SHerbert Xu 	.sendpage	=	skcipher_sendpage_nokey,
303a0fa2d03SHerbert Xu 	.recvmsg	=	skcipher_recvmsg_nokey,
304*b28fc822SChristoph Hellwig 	.poll_mask	=	af_alg_poll_mask,
305a0fa2d03SHerbert Xu };
306a0fa2d03SHerbert Xu 
3078ff59090SHerbert Xu static void *skcipher_bind(const char *name, u32 type, u32 mask)
3088ff59090SHerbert Xu {
309f8d33facSEric Biggers 	return crypto_alloc_skcipher(name, type, mask);
3108ff59090SHerbert Xu }
3118ff59090SHerbert Xu 
3128ff59090SHerbert Xu static void skcipher_release(void *private)
3138ff59090SHerbert Xu {
314f8d33facSEric Biggers 	crypto_free_skcipher(private);
3158ff59090SHerbert Xu }
3168ff59090SHerbert Xu 
3178ff59090SHerbert Xu static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
3188ff59090SHerbert Xu {
319f8d33facSEric Biggers 	return crypto_skcipher_setkey(private, key, keylen);
3208ff59090SHerbert Xu }
3218ff59090SHerbert Xu 
3228ff59090SHerbert Xu static void skcipher_sock_destruct(struct sock *sk)
3238ff59090SHerbert Xu {
3248ff59090SHerbert Xu 	struct alg_sock *ask = alg_sk(sk);
3252d97591eSStephan Mueller 	struct af_alg_ctx *ctx = ask->private;
326e870456dSStephan Mueller 	struct sock *psk = ask->parent;
327e870456dSStephan Mueller 	struct alg_sock *pask = alg_sk(psk);
328f8d33facSEric Biggers 	struct crypto_skcipher *tfm = pask->private;
3298ff59090SHerbert Xu 
3302d97591eSStephan Mueller 	af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
3310d96e4baSHerbert Xu 	sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
3328ff59090SHerbert Xu 	sock_kfree_s(sk, ctx, ctx->len);
3338ff59090SHerbert Xu 	af_alg_release_parent(sk);
3348ff59090SHerbert Xu }
3358ff59090SHerbert Xu 
336d7b65aeeSHerbert Xu static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
3378ff59090SHerbert Xu {
3382d97591eSStephan Mueller 	struct af_alg_ctx *ctx;
3398ff59090SHerbert Xu 	struct alg_sock *ask = alg_sk(sk);
340f8d33facSEric Biggers 	struct crypto_skcipher *tfm = private;
341e870456dSStephan Mueller 	unsigned int len = sizeof(*ctx);
3428ff59090SHerbert Xu 
3438ff59090SHerbert Xu 	ctx = sock_kmalloc(sk, len, GFP_KERNEL);
3448ff59090SHerbert Xu 	if (!ctx)
3458ff59090SHerbert Xu 		return -ENOMEM;
3468ff59090SHerbert Xu 
347f8d33facSEric Biggers 	ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(tfm),
3488ff59090SHerbert Xu 			       GFP_KERNEL);
3498ff59090SHerbert Xu 	if (!ctx->iv) {
3508ff59090SHerbert Xu 		sock_kfree_s(sk, ctx, len);
3518ff59090SHerbert Xu 		return -ENOMEM;
3528ff59090SHerbert Xu 	}
3538ff59090SHerbert Xu 
354f8d33facSEric Biggers 	memset(ctx->iv, 0, crypto_skcipher_ivsize(tfm));
3558ff59090SHerbert Xu 
356e870456dSStephan Mueller 	INIT_LIST_HEAD(&ctx->tsgl_list);
3578ff59090SHerbert Xu 	ctx->len = len;
3588ff59090SHerbert Xu 	ctx->used = 0;
359af955bf1SJonathan Cameron 	atomic_set(&ctx->rcvused, 0);
3608ff59090SHerbert Xu 	ctx->more = 0;
3618ff59090SHerbert Xu 	ctx->merge = 0;
3628ff59090SHerbert Xu 	ctx->enc = 0;
3632c3f8b16SGilad Ben-Yossef 	crypto_init_wait(&ctx->wait);
3648ff59090SHerbert Xu 
3658ff59090SHerbert Xu 	ask->private = ctx;
3668ff59090SHerbert Xu 
3678ff59090SHerbert Xu 	sk->sk_destruct = skcipher_sock_destruct;
3688ff59090SHerbert Xu 
3698ff59090SHerbert Xu 	return 0;
3708ff59090SHerbert Xu }
3718ff59090SHerbert Xu 
372a0fa2d03SHerbert Xu static int skcipher_accept_parent(void *private, struct sock *sk)
373a0fa2d03SHerbert Xu {
374f8d33facSEric Biggers 	struct crypto_skcipher *tfm = private;
375a0fa2d03SHerbert Xu 
376f8d33facSEric Biggers 	if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
377a0fa2d03SHerbert Xu 		return -ENOKEY;
378a0fa2d03SHerbert Xu 
379d7b65aeeSHerbert Xu 	return skcipher_accept_parent_nokey(private, sk);
380a0fa2d03SHerbert Xu }
381a0fa2d03SHerbert Xu 
3828ff59090SHerbert Xu static const struct af_alg_type algif_type_skcipher = {
3838ff59090SHerbert Xu 	.bind		=	skcipher_bind,
3848ff59090SHerbert Xu 	.release	=	skcipher_release,
3858ff59090SHerbert Xu 	.setkey		=	skcipher_setkey,
3868ff59090SHerbert Xu 	.accept		=	skcipher_accept_parent,
387a0fa2d03SHerbert Xu 	.accept_nokey	=	skcipher_accept_parent_nokey,
3888ff59090SHerbert Xu 	.ops		=	&algif_skcipher_ops,
389a0fa2d03SHerbert Xu 	.ops_nokey	=	&algif_skcipher_ops_nokey,
3908ff59090SHerbert Xu 	.name		=	"skcipher",
3918ff59090SHerbert Xu 	.owner		=	THIS_MODULE
3928ff59090SHerbert Xu };
3938ff59090SHerbert Xu 
3948ff59090SHerbert Xu static int __init algif_skcipher_init(void)
3958ff59090SHerbert Xu {
3968ff59090SHerbert Xu 	return af_alg_register_type(&algif_type_skcipher);
3978ff59090SHerbert Xu }
3988ff59090SHerbert Xu 
3998ff59090SHerbert Xu static void __exit algif_skcipher_exit(void)
4008ff59090SHerbert Xu {
4018ff59090SHerbert Xu 	int err = af_alg_unregister_type(&algif_type_skcipher);
4028ff59090SHerbert Xu 	BUG_ON(err);
4038ff59090SHerbert Xu }
4048ff59090SHerbert Xu 
4058ff59090SHerbert Xu module_init(algif_skcipher_init);
4068ff59090SHerbert Xu module_exit(algif_skcipher_exit);
4078ff59090SHerbert Xu MODULE_LICENSE("GPL");
408