[mirror_ubuntu-bionic-kernel.git] / crypto / algif_skcipher.c

/*
 * algif_skcipher: User-space interface for skcipher algorithms
 *
 * This file provides the user-space API for symmetric key ciphers.
 *
 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * The following concept of the memory management is used:
 *
 * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
 * filled by user space with the data submitted via sendpage/sendmsg. Filling
 * up the TX SGL does not cause a crypto operation -- the data will only be
 * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
 * provide a buffer which is tracked with the RX SGL.
 *
 * During the processing of the recvmsg operation, the cipher request is
 * allocated and prepared. As part of the recvmsg operation, the processed
 * TX buffers are extracted from the TX SGL into a separate SGL.
 *
 * After the completion of the crypto operation, the RX SGL and the cipher
 * request is released. The extracted TX SGL parts are released together with
 * the RX SGL release.
 */

#include <crypto/scatterwalk.h>
#include <crypto/skcipher.h>
#include <crypto/if_alg.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/net.h>
#include <net/sock.h>

struct skcipher_tfm {
	struct crypto_skcipher *skcipher;
	bool has_key;
};

static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
			    size_t size)
{
	struct sock *sk = sock->sk;
	struct alg_sock *ask = alg_sk(sk);
	struct sock *psk = ask->parent;
	struct alg_sock *pask = alg_sk(psk);
	struct skcipher_tfm *skc = pask->private;
	struct crypto_skcipher *tfm = skc->skcipher;
	unsigned ivsize = crypto_skcipher_ivsize(tfm);

	return af_alg_sendmsg(sock, msg, size, ivsize);
}

static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
			     size_t ignored, int flags)
{
	struct sock *sk = sock->sk;
	struct alg_sock *ask = alg_sk(sk);
	struct sock *psk = ask->parent;
	struct alg_sock *pask = alg_sk(psk);
	struct af_alg_ctx *ctx = ask->private;
	struct skcipher_tfm *skc = pask->private;
	struct crypto_skcipher *tfm = skc->skcipher;
	unsigned int bs = crypto_skcipher_blocksize(tfm);
	struct af_alg_async_req *areq;
	int err = 0;
	size_t len = 0;

	if (!ctx->used) {
		err = af_alg_wait_for_data(sk, flags);
		if (err)
			return err;
	}

	/* Allocate cipher request for current operation. */
	areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
				     crypto_skcipher_reqsize(tfm));
	if (IS_ERR(areq))
		return PTR_ERR(areq);

	/* convert iovecs of output buffers into RX SGL */
	err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);
	if (err)
		goto free;

	/* Process only as much RX buffers for which we have TX data */
	if (len > ctx->used)
		len = ctx->used;

	/*
	 * If more buffers are to be expected to be processed, process only
	 * full block size buffers.
	 */
	if (ctx->more || len < ctx->used)
		len -= len % bs;

	/*
	 * Create a per request TX SGL for this request which tracks the
	 * SG entries from the global TX SGL.
	 */
	areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
	if (!areq->tsgl_entries)
		areq->tsgl_entries = 1;
	areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries,
				  GFP_KERNEL);
	if (!areq->tsgl) {
		err = -ENOMEM;
		goto free;
	}
	sg_init_table(areq->tsgl, areq->tsgl_entries);
	af_alg_pull_tsgl(sk, len, areq->tsgl, 0);

	/* Initialize the crypto operation */
	skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm);
	skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl,
				   areq->first_rsgl.sgl.sg, len, ctx->iv);

	if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
		/* AIO operation */
		sock_hold(sk);
		areq->iocb = msg->msg_iocb;

		/* Remember output size that will be generated. */
		areq->outlen = len;

		skcipher_request_set_callback(&areq->cra_u.skcipher_req,
					      CRYPTO_TFM_REQ_MAY_SLEEP,
					      af_alg_async_cb, areq);
		err = ctx->enc ?
			crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
			crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);

		/* AIO operation in progress */
		if (err == -EINPROGRESS || err == -EBUSY)
			return -EIOCBQUEUED;

		sock_put(sk);
	} else {
		/* Synchronous operation */
		skcipher_request_set_callback(&areq->cra_u.skcipher_req,
					      CRYPTO_TFM_REQ_MAY_SLEEP |
					      CRYPTO_TFM_REQ_MAY_BACKLOG,
					      crypto_req_done, &ctx->wait);
		err = crypto_wait_req(ctx->enc ?
			crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
			crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
						 &ctx->wait);
	}


free:
	af_alg_free_resources(areq);

	return err ? err : len;
}

static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
			    size_t ignored, int flags)
{
	struct sock *sk = sock->sk;
	int ret = 0;

	lock_sock(sk);
	while (msg_data_left(msg)) {
		int err = _skcipher_recvmsg(sock, msg, ignored, flags);

		/*
		 * This error covers -EIOCBQUEUED which implies that we can
		 * only handle one AIO request. If the caller wants to have
		 * multiple AIO requests in parallel, he must make multiple
		 * separate AIO calls.
		 *
		 * Also return the error if no data has been processed so far.
		 */
		if (err <= 0) {
			if (err == -EIOCBQUEUED || !ret)
				ret = err;
			goto out;
		}

		ret += err;
	}

out:
	af_alg_wmem_wakeup(sk);
	release_sock(sk);
	return ret;
}


static struct proto_ops algif_skcipher_ops = {
	.family		=	PF_ALG,

	.connect	=	sock_no_connect,
	.socketpair	=	sock_no_socketpair,
	.getname	=	sock_no_getname,
	.ioctl		=	sock_no_ioctl,
	.listen		=	sock_no_listen,
	.shutdown	=	sock_no_shutdown,
	.getsockopt	=	sock_no_getsockopt,
	.mmap		=	sock_no_mmap,
	.bind		=	sock_no_bind,
	.accept		=	sock_no_accept,
	.setsockopt	=	sock_no_setsockopt,

	.release	=	af_alg_release,
	.sendmsg	=	skcipher_sendmsg,
	.sendpage	=	af_alg_sendpage,
	.recvmsg	=	skcipher_recvmsg,
	.poll		=	af_alg_poll,
};

static int skcipher_check_key(struct socket *sock)
{
	int err = 0;
	struct sock *psk;
	struct alg_sock *pask;
	struct skcipher_tfm *tfm;
	struct sock *sk = sock->sk;
	struct alg_sock *ask = alg_sk(sk);

	lock_sock(sk);
	if (ask->refcnt)
		goto unlock_child;

	psk = ask->parent;
	pask = alg_sk(ask->parent);
	tfm = pask->private;

	err = -ENOKEY;
	lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
	if (!tfm->has_key)
		goto unlock;

	if (!pask->refcnt++)
		sock_hold(psk);

	ask->refcnt = 1;
	sock_put(psk);

	err = 0;

unlock:
	release_sock(psk);
unlock_child:
	release_sock(sk);

	return err;
}

static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
				  size_t size)
{
	int err;

	err = skcipher_check_key(sock);
	if (err)
		return err;

	return skcipher_sendmsg(sock, msg, size);
}

static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
				       int offset, size_t size, int flags)
{
	int err;

	err = skcipher_check_key(sock);
	if (err)
		return err;

	return af_alg_sendpage(sock, page, offset, size, flags);
}

static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
				  size_t ignored, int flags)
{
	int err;

	err = skcipher_check_key(sock);
	if (err)
		return err;

	return skcipher_recvmsg(sock, msg, ignored, flags);
}

static struct proto_ops algif_skcipher_ops_nokey = {
	.family		=	PF_ALG,

	.connect	=	sock_no_connect,
	.socketpair	=	sock_no_socketpair,
	.getname	=	sock_no_getname,
	.ioctl		=	sock_no_ioctl,
	.listen		=	sock_no_listen,
	.shutdown	=	sock_no_shutdown,
	.getsockopt	=	sock_no_getsockopt,
	.mmap		=	sock_no_mmap,
	.bind		=	sock_no_bind,
	.accept		=	sock_no_accept,
	.setsockopt	=	sock_no_setsockopt,

	.release	=	af_alg_release,
	.sendmsg	=	skcipher_sendmsg_nokey,
	.sendpage	=	skcipher_sendpage_nokey,
	.recvmsg	=	skcipher_recvmsg_nokey,
	.poll		=	af_alg_poll,
};

static void *skcipher_bind(const char *name, u32 type, u32 mask)
{
	struct skcipher_tfm *tfm;
	struct crypto_skcipher *skcipher;

	tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
	if (!tfm)
		return ERR_PTR(-ENOMEM);

	skcipher = crypto_alloc_skcipher(name, type, mask);
	if (IS_ERR(skcipher)) {
		kfree(tfm);
		return ERR_CAST(skcipher);
	}

	tfm->skcipher = skcipher;

	return tfm;
}

static void skcipher_release(void *private)
{
	struct skcipher_tfm *tfm = private;

	crypto_free_skcipher(tfm->skcipher);
	kfree(tfm);
}

static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
{
	struct skcipher_tfm *tfm = private;
	int err;

	err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
	tfm->has_key = !err;

	return err;
}

static void skcipher_sock_destruct(struct sock *sk)
{
	struct alg_sock *ask = alg_sk(sk);
	struct af_alg_ctx *ctx = ask->private;
	struct sock *psk = ask->parent;
	struct alg_sock *pask = alg_sk(psk);
	struct skcipher_tfm *skc = pask->private;
	struct crypto_skcipher *tfm = skc->skcipher;

	af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
	sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
	sock_kfree_s(sk, ctx, ctx->len);
	af_alg_release_parent(sk);
}

static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
{
	struct af_alg_ctx *ctx;
	struct alg_sock *ask = alg_sk(sk);
	struct skcipher_tfm *tfm = private;
	struct crypto_skcipher *skcipher = tfm->skcipher;
	unsigned int len = sizeof(*ctx);

	ctx = sock_kmalloc(sk, len, GFP_KERNEL);
	if (!ctx)
		return -ENOMEM;

	ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
			       GFP_KERNEL);
	if (!ctx->iv) {
		sock_kfree_s(sk, ctx, len);
		return -ENOMEM;
	}

	memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));

	INIT_LIST_HEAD(&ctx->tsgl_list);
	ctx->len = len;
	ctx->used = 0;
	atomic_set(&ctx->rcvused, 0);
	ctx->more = 0;
	ctx->merge = 0;
	ctx->enc = 0;
	crypto_init_wait(&ctx->wait);

	ask->private = ctx;

	sk->sk_destruct = skcipher_sock_destruct;

	return 0;
}

static int skcipher_accept_parent(void *private, struct sock *sk)
{
	struct skcipher_tfm *tfm = private;

	if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
		return -ENOKEY;

	return skcipher_accept_parent_nokey(private, sk);
}

static const struct af_alg_type algif_type_skcipher = {
	.bind		=	skcipher_bind,
	.release	=	skcipher_release,
	.setkey		=	skcipher_setkey,
	.accept		=	skcipher_accept_parent,
	.accept_nokey	=	skcipher_accept_parent_nokey,
	.ops		=	&algif_skcipher_ops,
	.ops_nokey	=	&algif_skcipher_ops_nokey,
	.name		=	"skcipher",
	.owner		=	THIS_MODULE
};

static int __init algif_skcipher_init(void)
{
	return af_alg_register_type(&algif_type_skcipher);
}

static void __exit algif_skcipher_exit(void)
{
	int err = af_alg_unregister_type(&algif_type_skcipher);
	BUG_ON(err);
}

module_init(algif_skcipher_init);
module_exit(algif_skcipher_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
8ff59090 HX	1	/*
	2	* algif_skcipher: User-space interface for skcipher algorithms
	3	*
	4	* This file provides the user-space API for symmetric key ciphers.
	5	*
	6	* Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
	7	*
	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)
	11	* any later version.
	12	*
e870456d SM	13	* The following concept of the memory management is used:
	14	*
	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.
	20	*
	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.
	24	*
	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
	27	* the RX SGL release.
8ff59090 HX	28	*/
	29
	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>
	36	#include <linux/mm.h>
	37	#include <linux/module.h>
	38	#include <linux/net.h>
	39	#include <net/sock.h>
	40
dd504589 HX	41	struct skcipher_tfm {
	42	struct crypto_skcipher *skcipher;
	43	bool has_key;
	44	};
	45
1b784140 YX	46	static int skcipher_sendmsg(struct socket sock, struct msghdr msg,
1b784140 YX	47	size_t size)
8ff59090 HX	48	{
	49	struct sock *sk = sock->sk;
	50	struct alg_sock *ask = alg_sk(sk);
6454c2b8 HX	51	struct sock *psk = ask->parent;
6454c2b8 HX	52	struct alg_sock *pask = alg_sk(psk);
6454c2b8 HX	53	struct skcipher_tfm *skc = pask->private;
6454c2b8 HX	54	struct crypto_skcipher *tfm = skc->skcipher;
0d96e4ba	55	unsigned ivsize = crypto_skcipher_ivsize(tfm);
8ff59090	56
2d97591e	57	return af_alg_sendmsg(sock, msg, size, ivsize);
a596999b TS	58	}
a596999b TS	59
e870456d SM	60	static int _skcipher_recvmsg(struct socket sock, struct msghdr msg,
e870456d SM	61	size_t ignored, int flags)
a596999b TS	62	{
	63	struct sock *sk = sock->sk;
	64	struct alg_sock *ask = alg_sk(sk);
ec69bbfb HX	65	struct sock *psk = ask->parent;
ec69bbfb HX	66	struct alg_sock *pask = alg_sk(psk);
2d97591e	67	struct af_alg_ctx *ctx = ask->private;
ec69bbfb HX	68	struct skcipher_tfm *skc = pask->private;
ec69bbfb HX	69	struct crypto_skcipher *tfm = skc->skcipher;
e870456d	70	unsigned int bs = crypto_skcipher_blocksize(tfm);
2d97591e	71	struct af_alg_async_req *areq;
e870456d SM	72	int err = 0;
e870456d SM	73	size_t len = 0;
ec69bbfb	74
11edb555 SM	75	if (!ctx->used) {
	76	err = af_alg_wait_for_data(sk, flags);
	77	if (err)
	78	return err;
	79	}
	80
e870456d	81	/* Allocate cipher request for current operation. */
2d97591e SM	82	areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
	83	crypto_skcipher_reqsize(tfm));
	84	if (IS_ERR(areq))
	85	return PTR_ERR(areq);
a596999b	86
e870456d	87	/* convert iovecs of output buffers into RX SGL */
2d97591e SM	88	err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);
	89	if (err)
	90	goto free;
a596999b	91
e870456d SM	92	/* Process only as much RX buffers for which we have TX data */
	93	if (len > ctx->used)
	94	len = ctx->used;
	95
	96	/*
	97	* If more buffers are to be expected to be processed, process only
	98	* full block size buffers.
	99	*/
	100	if (ctx->more \|\| len < ctx->used)
	101	len -= len % bs;
	102
	103	/*
	104	* Create a per request TX SGL for this request which tracks the
	105	* SG entries from the global TX SGL.
	106	*/
2d97591e	107	areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
e870456d SM	108	if (!areq->tsgl_entries)
	109	areq->tsgl_entries = 1;
	110	areq->tsgl = sock_kmalloc(sk, sizeof(areq->tsgl) areq->tsgl_entries,
	111	GFP_KERNEL);
	112	if (!areq->tsgl) {
	113	err = -ENOMEM;
	114	goto free;
	115	}
	116	sg_init_table(areq->tsgl, areq->tsgl_entries);
2d97591e	117	af_alg_pull_tsgl(sk, len, areq->tsgl, 0);
e870456d SM	118
e870456d SM	119	/* Initialize the crypto operation */
2d97591e SM	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);
e870456d SM	123
	124	if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
	125	/* AIO operation */
7d2c3f54	126	sock_hold(sk);
e870456d	127	areq->iocb = msg->msg_iocb;
d53c5135 SM	128
	129	/* Remember output size that will be generated. */
	130	areq->outlen = len;
	131
2d97591e	132	skcipher_request_set_callback(&areq->cra_u.skcipher_req,
e870456d	133	CRYPTO_TFM_REQ_MAY_SLEEP,
2d97591e SM	134	af_alg_async_cb, areq);
	135	err = ctx->enc ?
	136	crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
	137	crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
7d2c3f54 SM	138
7d2c3f54 SM	139	/* AIO operation in progress */
d53c5135	140	if (err == -EINPROGRESS \|\| err == -EBUSY)
7d2c3f54	141	return -EIOCBQUEUED;
7d2c3f54 SM	142
7d2c3f54 SM	143	sock_put(sk);
e870456d SM	144	} else {
e870456d SM	145	/* Synchronous operation */
2d97591e	146	skcipher_request_set_callback(&areq->cra_u.skcipher_req,
e870456d SM	147	CRYPTO_TFM_REQ_MAY_SLEEP \|
e870456d SM	148	CRYPTO_TFM_REQ_MAY_BACKLOG,
2c3f8b16 GBY	149	crypto_req_done, &ctx->wait);
2c3f8b16 GBY	150	err = crypto_wait_req(ctx->enc ?
2d97591e SM	151	crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
2d97591e SM	152	crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
2c3f8b16	153	&ctx->wait);
e870456d	154	}
033f46b3	155
e870456d	156
a596999b	157	free:
7d2c3f54	158	af_alg_free_resources(areq);
e870456d SM	159
e870456d SM	160	return err ? err : len;
a596999b TS	161	}
a596999b TS	162
e870456d SM	163	static int skcipher_recvmsg(struct socket sock, struct msghdr msg,
e870456d SM	164	size_t ignored, int flags)
8ff59090 HX	165	{
8ff59090 HX	166	struct sock *sk = sock->sk;
e870456d	167	int ret = 0;
8ff59090 HX	168
8ff59090 HX	169	lock_sock(sk);
01e97e65	170	while (msg_data_left(msg)) {
e870456d SM	171	int err = _skcipher_recvmsg(sock, msg, ignored, flags);
	172
	173	/*
	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.
5703c826 SM	178	*
5703c826 SM	179	* Also return the error if no data has been processed so far.
e870456d SM	180	*/
e870456d SM	181	if (err <= 0) {
5703c826	182	if (err == -EIOCBQUEUED \|\| !ret)
e870456d SM	183	ret = err;
e870456d SM	184	goto out;
1d10eb2f AV	185	}
1d10eb2f AV	186
e870456d	187	ret += err;
8ff59090 HX	188	}
8ff59090 HX	189
e870456d	190	out:
2d97591e	191	af_alg_wmem_wakeup(sk);
8ff59090	192	release_sock(sk);
e870456d	193	return ret;
a596999b	194	}
8ff59090	195
8ff59090 HX	196
	197	static struct proto_ops algif_skcipher_ops = {
	198	.family = PF_ALG,
	199
	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,
	211
	212	.release = af_alg_release,
	213	.sendmsg = skcipher_sendmsg,
2d97591e	214	.sendpage = af_alg_sendpage,
8ff59090	215	.recvmsg = skcipher_recvmsg,
2d97591e	216	.poll = af_alg_poll,
8ff59090 HX	217	};
8ff59090 HX	218
a0fa2d03 HX	219	static int skcipher_check_key(struct socket *sock)
a0fa2d03 HX	220	{
1822793a	221	int err = 0;
a0fa2d03 HX	222	struct sock *psk;
	223	struct alg_sock *pask;
	224	struct skcipher_tfm *tfm;
	225	struct sock *sk = sock->sk;
	226	struct alg_sock *ask = alg_sk(sk);
	227
1822793a	228	lock_sock(sk);
a0fa2d03	229	if (ask->refcnt)
1822793a	230	goto unlock_child;
a0fa2d03 HX	231
	232	psk = ask->parent;
	233	pask = alg_sk(ask->parent);
	234	tfm = pask->private;
	235
	236	err = -ENOKEY;
1822793a	237	lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
a0fa2d03 HX	238	if (!tfm->has_key)
	239	goto unlock;
	240
	241	if (!pask->refcnt++)
	242	sock_hold(psk);
	243
	244	ask->refcnt = 1;
	245	sock_put(psk);
	246
	247	err = 0;
	248
	249	unlock:
	250	release_sock(psk);
1822793a HX	251	unlock_child:
1822793a HX	252	release_sock(sk);
a0fa2d03 HX	253
	254	return err;
	255	}
	256
	257	static int skcipher_sendmsg_nokey(struct socket sock, struct msghdr msg,
	258	size_t size)
	259	{
	260	int err;
	261
	262	err = skcipher_check_key(sock);
	263	if (err)
	264	return err;
	265
	266	return skcipher_sendmsg(sock, msg, size);
	267	}
	268
	269	static ssize_t skcipher_sendpage_nokey(struct socket sock, struct page page,
	270	int offset, size_t size, int flags)
	271	{
	272	int err;
	273
	274	err = skcipher_check_key(sock);
	275	if (err)
	276	return err;
	277
2d97591e	278	return af_alg_sendpage(sock, page, offset, size, flags);
a0fa2d03 HX	279	}
	280
	281	static int skcipher_recvmsg_nokey(struct socket sock, struct msghdr msg,
	282	size_t ignored, int flags)
	283	{
	284	int err;
	285
	286	err = skcipher_check_key(sock);
	287	if (err)
	288	return err;
	289
	290	return skcipher_recvmsg(sock, msg, ignored, flags);
	291	}
	292
	293	static struct proto_ops algif_skcipher_ops_nokey = {
	294	.family = PF_ALG,
	295
	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,
	307
	308	.release = af_alg_release,
	309	.sendmsg = skcipher_sendmsg_nokey,
	310	.sendpage = skcipher_sendpage_nokey,
	311	.recvmsg = skcipher_recvmsg_nokey,
2d97591e	312	.poll = af_alg_poll,
a0fa2d03 HX	313	};
a0fa2d03 HX	314
8ff59090 HX	315	static void skcipher_bind(const char name, u32 type, u32 mask)
8ff59090 HX	316	{
dd504589 HX	317	struct skcipher_tfm *tfm;
	318	struct crypto_skcipher *skcipher;
	319
	320	tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
	321	if (!tfm)
	322	return ERR_PTR(-ENOMEM);
	323
	324	skcipher = crypto_alloc_skcipher(name, type, mask);
	325	if (IS_ERR(skcipher)) {
	326	kfree(tfm);
	327	return ERR_CAST(skcipher);
	328	}
	329
	330	tfm->skcipher = skcipher;
	331
	332	return tfm;
8ff59090 HX	333	}
	334
	335	static void skcipher_release(void *private)
	336	{
dd504589 HX	337	struct skcipher_tfm *tfm = private;
	338
	339	crypto_free_skcipher(tfm->skcipher);
	340	kfree(tfm);
8ff59090 HX	341	}
	342
	343	static int skcipher_setkey(void private, const u8 key, unsigned int keylen)
	344	{
dd504589 HX	345	struct skcipher_tfm *tfm = private;
	346	int err;
	347
	348	err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
	349	tfm->has_key = !err;
	350
	351	return err;
8ff59090 HX	352	}
	353
	354	static void skcipher_sock_destruct(struct sock *sk)
	355	{
	356	struct alg_sock *ask = alg_sk(sk);
2d97591e	357	struct af_alg_ctx *ctx = ask->private;
e870456d SM	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;
a596999b	362
2d97591e	363	af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
0d96e4ba	364	sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
8ff59090 HX	365	sock_kfree_s(sk, ctx, ctx->len);
	366	af_alg_release_parent(sk);
	367	}
	368
d7b65aee	369	static int skcipher_accept_parent_nokey(void private, struct sock sk)
8ff59090	370	{
2d97591e	371	struct af_alg_ctx *ctx;
8ff59090	372	struct alg_sock *ask = alg_sk(sk);
dd504589 HX	373	struct skcipher_tfm *tfm = private;
dd504589 HX	374	struct crypto_skcipher *skcipher = tfm->skcipher;
e870456d	375	unsigned int len = sizeof(*ctx);
8ff59090 HX	376
	377	ctx = sock_kmalloc(sk, len, GFP_KERNEL);
	378	if (!ctx)
	379	return -ENOMEM;
	380
dd504589	381	ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
8ff59090 HX	382	GFP_KERNEL);
	383	if (!ctx->iv) {
	384	sock_kfree_s(sk, ctx, len);
	385	return -ENOMEM;
	386	}
	387
dd504589	388	memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));
8ff59090	389
e870456d	390	INIT_LIST_HEAD(&ctx->tsgl_list);
8ff59090 HX	391	ctx->len = len;
8ff59090 HX	392	ctx->used = 0;
af955bf1	393	atomic_set(&ctx->rcvused, 0);
8ff59090 HX	394	ctx->more = 0;
	395	ctx->merge = 0;
	396	ctx->enc = 0;
2c3f8b16	397	crypto_init_wait(&ctx->wait);
8ff59090 HX	398
	399	ask->private = ctx;
	400
8ff59090 HX	401	sk->sk_destruct = skcipher_sock_destruct;
	402
	403	return 0;
	404	}
	405
a0fa2d03 HX	406	static int skcipher_accept_parent(void private, struct sock sk)
	407	{
	408	struct skcipher_tfm *tfm = private;
	409
6e8d8ecf	410	if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
a0fa2d03 HX	411	return -ENOKEY;
a0fa2d03 HX	412
d7b65aee	413	return skcipher_accept_parent_nokey(private, sk);
a0fa2d03 HX	414	}
a0fa2d03 HX	415
8ff59090 HX	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,
a0fa2d03	421	.accept_nokey = skcipher_accept_parent_nokey,
8ff59090	422	.ops = &algif_skcipher_ops,
a0fa2d03	423	.ops_nokey = &algif_skcipher_ops_nokey,
8ff59090 HX	424	.name = "skcipher",
	425	.owner = THIS_MODULE
	426	};
	427
	428	static int __init algif_skcipher_init(void)
	429	{
	430	return af_alg_register_type(&algif_type_skcipher);
	431	}
	432
	433	static void __exit algif_skcipher_exit(void)
	434	{
	435	int err = af_alg_unregister_type(&algif_type_skcipher);
	436	BUG_ON(err);
	437	}
	438
	439	module_init(algif_skcipher_init);
	440	module_exit(algif_skcipher_exit);
	441	MODULE_LICENSE("GPL");