esp6.c 15.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 * Copyright (C)2002 USAGI/WIDE Project
3
 *
L
Linus Torvalds 已提交
4 5 6 7
 * 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.
8
 *
L
Linus Torvalds 已提交
9 10 11 12
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
13
 *
L
Linus Torvalds 已提交
14
 * You should have received a copy of the GNU General Public License
15
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
L
Linus Torvalds 已提交
16 17 18
 *
 * Authors
 *
19
 *	Mitsuru KANDA @USAGI       : IPv6 Support
20 21
 *	Kazunori MIYAZAWA @USAGI   :
 *	Kunihiro Ishiguro <kunihiro@ipinfusion.com>
22
 *
23
 *	This file is derived from net/ipv4/esp.c
L
Linus Torvalds 已提交
24 25
 */

26 27
#define pr_fmt(fmt) "IPv6: " fmt

28 29
#include <crypto/aead.h>
#include <crypto/authenc.h>
30
#include <linux/err.h>
L
Linus Torvalds 已提交
31 32 33 34
#include <linux/module.h>
#include <net/ip.h>
#include <net/xfrm.h>
#include <net/esp.h>
35
#include <linux/scatterlist.h>
H
Herbert Xu 已提交
36
#include <linux/kernel.h>
L
Linus Torvalds 已提交
37 38
#include <linux/pfkeyv2.h>
#include <linux/random.h>
39
#include <linux/slab.h>
40
#include <linux/spinlock.h>
41
#include <net/ip6_route.h>
L
Linus Torvalds 已提交
42 43
#include <net/icmp.h>
#include <net/ipv6.h>
44
#include <net/protocol.h>
L
Linus Torvalds 已提交
45 46
#include <linux/icmpv6.h>

47 48 49 50 51 52 53
struct esp_skb_cb {
	struct xfrm_skb_cb xfrm;
	void *tmp;
};

#define ESP_SKB_CB(__skb) ((struct esp_skb_cb *)&((__skb)->cb[0]))

54 55
static u32 esp6_get_mtu(struct xfrm_state *x, int mtu);

56 57 58
/*
 * Allocate an AEAD request structure with extra space for SG and IV.
 *
59 60 61
 * For alignment considerations the upper 32 bits of the sequence number are
 * placed at the front, if present. Followed by the IV, the request and finally
 * the SG list.
62 63 64
 *
 * TODO: Use spare space in skb for this where possible.
 */
65
static void *esp_alloc_tmp(struct crypto_aead *aead, int nfrags, int seqihlen)
66 67 68
{
	unsigned int len;

69 70 71 72
	len = seqihlen;

	len += crypto_aead_ivsize(aead);

73 74 75 76 77 78 79 80 81 82 83 84 85 86
	if (len) {
		len += crypto_aead_alignmask(aead) &
		       ~(crypto_tfm_ctx_alignment() - 1);
		len = ALIGN(len, crypto_tfm_ctx_alignment());
	}

	len += sizeof(struct aead_givcrypt_request) + crypto_aead_reqsize(aead);
	len = ALIGN(len, __alignof__(struct scatterlist));

	len += sizeof(struct scatterlist) * nfrags;

	return kmalloc(len, GFP_ATOMIC);
}

87 88 89 90 91 92
static inline __be32 *esp_tmp_seqhi(void *tmp)
{
	return PTR_ALIGN((__be32 *)tmp, __alignof__(__be32));
}

static inline u8 *esp_tmp_iv(struct crypto_aead *aead, void *tmp, int seqhilen)
93 94
{
	return crypto_aead_ivsize(aead) ?
95 96
	       PTR_ALIGN((u8 *)tmp + seqhilen,
			 crypto_aead_alignmask(aead) + 1) : tmp + seqhilen;
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
}

static inline struct aead_givcrypt_request *esp_tmp_givreq(
	struct crypto_aead *aead, u8 *iv)
{
	struct aead_givcrypt_request *req;

	req = (void *)PTR_ALIGN(iv + crypto_aead_ivsize(aead),
				crypto_tfm_ctx_alignment());
	aead_givcrypt_set_tfm(req, aead);
	return req;
}

static inline struct aead_request *esp_tmp_req(struct crypto_aead *aead, u8 *iv)
{
	struct aead_request *req;

	req = (void *)PTR_ALIGN(iv + crypto_aead_ivsize(aead),
				crypto_tfm_ctx_alignment());
	aead_request_set_tfm(req, aead);
	return req;
}

static inline struct scatterlist *esp_req_sg(struct crypto_aead *aead,
					     struct aead_request *req)
{
	return (void *)ALIGN((unsigned long)(req + 1) +
			     crypto_aead_reqsize(aead),
			     __alignof__(struct scatterlist));
}

static inline struct scatterlist *esp_givreq_sg(
	struct crypto_aead *aead, struct aead_givcrypt_request *req)
{
	return (void *)ALIGN((unsigned long)(req + 1) +
			     crypto_aead_reqsize(aead),
			     __alignof__(struct scatterlist));
}

static void esp_output_done(struct crypto_async_request *base, int err)
{
	struct sk_buff *skb = base->data;

	kfree(ESP_SKB_CB(skb)->tmp);
	xfrm_output_resume(skb, err);
}

L
Linus Torvalds 已提交
144 145 146
static int esp6_output(struct xfrm_state *x, struct sk_buff *skb)
{
	int err;
147
	struct ip_esp_hdr *esph;
148 149 150 151
	struct crypto_aead *aead;
	struct aead_givcrypt_request *req;
	struct scatterlist *sg;
	struct scatterlist *asg;
L
Linus Torvalds 已提交
152
	struct sk_buff *trailer;
153
	void *tmp;
L
Linus Torvalds 已提交
154 155 156
	int blksize;
	int clen;
	int alen;
157 158
	int plen;
	int tfclen;
L
Linus Torvalds 已提交
159
	int nfrags;
160 161 162
	int assoclen;
	int sglists;
	int seqhilen;
163
	u8 *iv;
164
	u8 *tail;
165
	__be32 *seqhi;
L
Linus Torvalds 已提交
166

167
	/* skb is pure payload to encrypt */
168
	aead = x->data;
169 170
	alen = crypto_aead_authsize(aead);

171 172 173 174 175 176 177 178 179
	tfclen = 0;
	if (x->tfcpad) {
		struct xfrm_dst *dst = (struct xfrm_dst *)skb_dst(skb);
		u32 padto;

		padto = min(x->tfcpad, esp6_get_mtu(x, dst->child_mtu_cached));
		if (skb->len < padto)
			tfclen = padto - skb->len;
	}
180
	blksize = ALIGN(crypto_aead_blocksize(aead), 4);
181 182
	clen = ALIGN(skb->len + 2 + tfclen, blksize);
	plen = clen - skb->len - tfclen;
L
Linus Torvalds 已提交
183

184 185
	err = skb_cow_data(skb, tfclen + plen + alen, &trailer);
	if (err < 0)
L
Linus Torvalds 已提交
186
		goto error;
187 188
	nfrags = err;

189 190 191 192 193 194 195 196 197 198 199
	assoclen = sizeof(*esph);
	sglists = 1;
	seqhilen = 0;

	if (x->props.flags & XFRM_STATE_ESN) {
		sglists += 2;
		seqhilen += sizeof(__be32);
		assoclen += seqhilen;
	}

	tmp = esp_alloc_tmp(aead, nfrags + sglists, seqhilen);
J
Julia Lawall 已提交
200 201
	if (!tmp) {
		err = -ENOMEM;
202
		goto error;
J
Julia Lawall 已提交
203
	}
204

205 206
	seqhi = esp_tmp_seqhi(tmp);
	iv = esp_tmp_iv(aead, tmp, seqhilen);
207 208
	req = esp_tmp_givreq(aead, iv);
	asg = esp_givreq_sg(aead, req);
209
	sg = asg + sglists;
L
Linus Torvalds 已提交
210 211

	/* Fill padding... */
212
	tail = skb_tail_pointer(trailer);
213 214 215 216
	if (tfclen) {
		memset(tail, 0, tfclen);
		tail += tfclen;
	}
L
Linus Torvalds 已提交
217 218
	do {
		int i;
219
		for (i = 0; i < plen - 2; i++)
220
			tail[i] = i + 1;
L
Linus Torvalds 已提交
221
	} while (0);
222 223
	tail[plen - 2] = plen - 2;
	tail[plen - 1] = *skb_mac_header(skb);
224
	pskb_put(skb, trailer, clen - skb->len + alen);
L
Linus Torvalds 已提交
225

226
	skb_push(skb, -skb_network_offset(skb));
227
	esph = ip_esp_hdr(skb);
228
	*skb_mac_header(skb) = IPPROTO_ESP;
L
Linus Torvalds 已提交
229 230

	esph->spi = x->id.spi;
231
	esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low);
L
Linus Torvalds 已提交
232

233 234 235 236
	sg_init_table(sg, nfrags);
	skb_to_sgvec(skb, sg,
		     esph->enc_data + crypto_aead_ivsize(aead) - skb->data,
		     clen + alen);
237 238 239 240 241 242 243 244 245

	if ((x->props.flags & XFRM_STATE_ESN)) {
		sg_init_table(asg, 3);
		sg_set_buf(asg, &esph->spi, sizeof(__be32));
		*seqhi = htonl(XFRM_SKB_CB(skb)->seq.output.hi);
		sg_set_buf(asg + 1, seqhi, seqhilen);
		sg_set_buf(asg + 2, &esph->seq_no, sizeof(__be32));
	} else
		sg_init_one(asg, esph, sizeof(*esph));
246

247 248
	aead_givcrypt_set_callback(req, 0, esp_output_done, skb);
	aead_givcrypt_set_crypt(req, sg, sg, clen, iv);
249
	aead_givcrypt_set_assoc(req, asg, assoclen);
250
	aead_givcrypt_set_giv(req, esph->enc_data,
251
			      XFRM_SKB_CB(skb)->seq.output.low);
L
Linus Torvalds 已提交
252

253 254 255 256
	ESP_SKB_CB(skb)->tmp = tmp;
	err = crypto_aead_givencrypt(req);
	if (err == -EINPROGRESS)
		goto error;
L
Linus Torvalds 已提交
257

258 259 260 261 262 263 264 265 266 267 268 269
	if (err == -EBUSY)
		err = NET_XMIT_DROP;

	kfree(tmp);

error:
	return err;
}

static int esp_input_done2(struct sk_buff *skb, int err)
{
	struct xfrm_state *x = xfrm_input_state(skb);
270
	struct crypto_aead *aead = x->data;
271 272 273 274 275 276 277 278
	int alen = crypto_aead_authsize(aead);
	int hlen = sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead);
	int elen = skb->len - hlen;
	int hdr_len = skb_network_header_len(skb);
	int padlen;
	u8 nexthdr[2];

	kfree(ESP_SKB_CB(skb)->tmp);
L
Linus Torvalds 已提交
279

280
	if (unlikely(err))
281
		goto out;
282

283 284
	if (skb_copy_bits(skb, skb->len - alen - 2, nexthdr, 2))
		BUG();
L
Linus Torvalds 已提交
285

286 287 288
	err = -EINVAL;
	padlen = nexthdr[0];
	if (padlen + 2 + alen >= elen) {
289 290
		net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n",
				    padlen + 2, elen - alen);
291
		goto out;
L
Linus Torvalds 已提交
292 293
	}

294
	/* ... check padding bits here. Silly. :-) */
295

296 297
	pskb_trim(skb, skb->len - alen - padlen - 2);
	__skb_pull(skb, hlen);
298 299 300 301
	if (x->props.mode == XFRM_MODE_TUNNEL)
		skb_reset_transport_header(skb);
	else
		skb_set_transport_header(skb, -hdr_len);
302 303 304 305 306 307 308 309

	err = nexthdr[1];

	/* RFC4303: Drop dummy packets without any error */
	if (err == IPPROTO_NONE)
		err = -EINVAL;

out:
L
Linus Torvalds 已提交
310 311 312
	return err;
}

313 314 315 316 317 318 319
static void esp_input_done(struct crypto_async_request *base, int err)
{
	struct sk_buff *skb = base->data;

	xfrm_input_resume(skb, esp_input_done2(skb, err));
}

320
static int esp6_input(struct xfrm_state *x, struct sk_buff *skb)
L
Linus Torvalds 已提交
321
{
322
	struct ip_esp_hdr *esph;
323
	struct crypto_aead *aead = x->data;
324
	struct aead_request *req;
L
Linus Torvalds 已提交
325
	struct sk_buff *trailer;
326
	int elen = skb->len - sizeof(*esph) - crypto_aead_ivsize(aead);
L
Linus Torvalds 已提交
327
	int nfrags;
328 329 330
	int assoclen;
	int sglists;
	int seqhilen;
L
Linus Torvalds 已提交
331
	int ret = 0;
332
	void *tmp;
333
	__be32 *seqhi;
334 335 336
	u8 *iv;
	struct scatterlist *sg;
	struct scatterlist *asg;
L
Linus Torvalds 已提交
337

338
	if (!pskb_may_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead))) {
L
Linus Torvalds 已提交
339
		ret = -EINVAL;
340
		goto out;
L
Linus Torvalds 已提交
341 342
	}

343
	if (elen <= 0) {
L
Linus Torvalds 已提交
344
		ret = -EINVAL;
345
		goto out;
L
Linus Torvalds 已提交
346 347
	}

348 349
	nfrags = skb_cow_data(skb, 0, &trailer);
	if (nfrags < 0) {
350 351 352 353
		ret = -EINVAL;
		goto out;
	}

354
	ret = -ENOMEM;
355 356 357 358 359 360 361 362 363 364 365 366

	assoclen = sizeof(*esph);
	sglists = 1;
	seqhilen = 0;

	if (x->props.flags & XFRM_STATE_ESN) {
		sglists += 2;
		seqhilen += sizeof(__be32);
		assoclen += seqhilen;
	}

	tmp = esp_alloc_tmp(aead, nfrags + sglists, seqhilen);
367 368
	if (!tmp)
		goto out;
L
Linus Torvalds 已提交
369

370
	ESP_SKB_CB(skb)->tmp = tmp;
371 372
	seqhi = esp_tmp_seqhi(tmp);
	iv = esp_tmp_iv(aead, tmp, seqhilen);
373 374
	req = esp_tmp_req(aead, iv);
	asg = esp_req_sg(aead, req);
375
	sg = asg + sglists;
L
Linus Torvalds 已提交
376

377
	skb->ip_summed = CHECKSUM_NONE;
L
Linus Torvalds 已提交
378

379
	esph = (struct ip_esp_hdr *)skb->data;
L
Linus Torvalds 已提交
380 381

	/* Get ivec. This can be wrong, check against another impls. */
382
	iv = esph->enc_data;
383

384 385
	sg_init_table(sg, nfrags);
	skb_to_sgvec(skb, sg, sizeof(*esph) + crypto_aead_ivsize(aead), elen);
386 387 388 389 390 391 392 393 394

	if ((x->props.flags & XFRM_STATE_ESN)) {
		sg_init_table(asg, 3);
		sg_set_buf(asg, &esph->spi, sizeof(__be32));
		*seqhi = XFRM_SKB_CB(skb)->seq.input.hi;
		sg_set_buf(asg + 1, seqhi, seqhilen);
		sg_set_buf(asg + 2, &esph->seq_no, sizeof(__be32));
	} else
		sg_init_one(asg, esph, sizeof(*esph));
395

396 397
	aead_request_set_callback(req, 0, esp_input_done, skb);
	aead_request_set_crypt(req, sg, sg, elen, iv);
398
	aead_request_set_assoc(req, asg, assoclen);
L
Linus Torvalds 已提交
399

400 401 402
	ret = crypto_aead_decrypt(req);
	if (ret == -EINPROGRESS)
		goto out;
403

404
	ret = esp_input_done2(skb, ret);
L
Linus Torvalds 已提交
405 406 407 408 409

out:
	return ret;
}

410
static u32 esp6_get_mtu(struct xfrm_state *x, int mtu)
L
Linus Torvalds 已提交
411
{
412 413
	struct crypto_aead *aead = x->data;
	u32 blksize = ALIGN(crypto_aead_blocksize(aead), 4);
414
	unsigned int net_adj;
L
Linus Torvalds 已提交
415

416 417 418 419
	if (x->props.mode != XFRM_MODE_TUNNEL)
		net_adj = sizeof(struct ipv6hdr);
	else
		net_adj = 0;
420

421
	return ((mtu - x->props.header_len - crypto_aead_authsize(aead) -
422
		 net_adj) & ~(blksize - 1)) + net_adj - 2;
L
Linus Torvalds 已提交
423 424
}

425 426
static int esp6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
		    u8 type, u8 code, int offset, __be32 info)
L
Linus Torvalds 已提交
427
{
A
Alexey Dobriyan 已提交
428
	struct net *net = dev_net(skb->dev);
429
	const struct ipv6hdr *iph = (const struct ipv6hdr *)skb->data;
430
	struct ip_esp_hdr *esph = (struct ip_esp_hdr *)(skb->data + offset);
L
Linus Torvalds 已提交
431 432
	struct xfrm_state *x;

433
	if (type != ICMPV6_PKT_TOOBIG &&
434
	    type != NDISC_REDIRECT)
435
		return 0;
L
Linus Torvalds 已提交
436

437 438
	x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr,
			      esph->spi, IPPROTO_ESP, AF_INET6);
L
Linus Torvalds 已提交
439
	if (!x)
440
		return 0;
441 442

	if (type == NDISC_REDIRECT)
443
		ip6_redirect(skb, net, skb->dev->ifindex, 0);
444 445
	else
		ip6_update_pmtu(skb, net, info, 0, 0);
L
Linus Torvalds 已提交
446
	xfrm_state_put(x);
447 448

	return 0;
L
Linus Torvalds 已提交
449 450 451 452
}

static void esp6_destroy(struct xfrm_state *x)
{
453
	struct crypto_aead *aead = x->data;
L
Linus Torvalds 已提交
454

455
	if (!aead)
L
Linus Torvalds 已提交
456 457
		return;

458
	crypto_free_aead(aead);
L
Linus Torvalds 已提交
459 460
}

461 462 463 464 465 466 467 468 469 470
static int esp_init_aead(struct xfrm_state *x)
{
	struct crypto_aead *aead;
	int err;

	aead = crypto_alloc_aead(x->aead->alg_name, 0, 0);
	err = PTR_ERR(aead);
	if (IS_ERR(aead))
		goto error;

471
	x->data = aead;
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486

	err = crypto_aead_setkey(aead, x->aead->alg_key,
				 (x->aead->alg_key_len + 7) / 8);
	if (err)
		goto error;

	err = crypto_aead_setauthsize(aead, x->aead->alg_icv_len / 8);
	if (err)
		goto error;

error:
	return err;
}

static int esp_init_authenc(struct xfrm_state *x)
L
Linus Torvalds 已提交
487
{
488 489 490 491 492 493 494 495
	struct crypto_aead *aead;
	struct crypto_authenc_key_param *param;
	struct rtattr *rta;
	char *key;
	char *p;
	char authenc_name[CRYPTO_MAX_ALG_NAME];
	unsigned int keylen;
	int err;
L
Linus Torvalds 已提交
496

497
	err = -EINVAL;
498
	if (!x->ealg)
499
		goto error;
500

501
	err = -ENAMETOOLONG;
502 503 504 505 506 507 508 509 510 511 512 513 514 515

	if ((x->props.flags & XFRM_STATE_ESN)) {
		if (snprintf(authenc_name, CRYPTO_MAX_ALG_NAME,
			     "authencesn(%s,%s)",
			     x->aalg ? x->aalg->alg_name : "digest_null",
			     x->ealg->alg_name) >= CRYPTO_MAX_ALG_NAME)
			goto error;
	} else {
		if (snprintf(authenc_name, CRYPTO_MAX_ALG_NAME,
			     "authenc(%s,%s)",
			     x->aalg ? x->aalg->alg_name : "digest_null",
			     x->ealg->alg_name) >= CRYPTO_MAX_ALG_NAME)
			goto error;
	}
516 517 518 519 520 521

	aead = crypto_alloc_aead(authenc_name, 0, 0);
	err = PTR_ERR(aead);
	if (IS_ERR(aead))
		goto error;

522
	x->data = aead;
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537

	keylen = (x->aalg ? (x->aalg->alg_key_len + 7) / 8 : 0) +
		 (x->ealg->alg_key_len + 7) / 8 + RTA_SPACE(sizeof(*param));
	err = -ENOMEM;
	key = kmalloc(keylen, GFP_KERNEL);
	if (!key)
		goto error;

	p = key;
	rta = (void *)p;
	rta->rta_type = CRYPTO_AUTHENC_KEYA_PARAM;
	rta->rta_len = RTA_LENGTH(sizeof(*param));
	param = RTA_DATA(rta);
	p += RTA_SPACE(sizeof(*param));

L
Linus Torvalds 已提交
538 539 540
	if (x->aalg) {
		struct xfrm_algo_desc *aalg_desc;

541 542
		memcpy(p, x->aalg->alg_key, (x->aalg->alg_key_len + 7) / 8);
		p += (x->aalg->alg_key_len + 7) / 8;
543

L
Linus Torvalds 已提交
544 545
		aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0);
		BUG_ON(!aalg_desc);
546

547
		err = -EINVAL;
548
		if (aalg_desc->uinfo.auth.icv_fullbits / 8 !=
549
		    crypto_aead_authsize(aead)) {
550 551 552 553
			pr_info("ESP: %s digestsize %u != %hu\n",
				x->aalg->alg_name,
				crypto_aead_authsize(aead),
				aalg_desc->uinfo.auth.icv_fullbits / 8);
554
			goto free_key;
L
Linus Torvalds 已提交
555
		}
556

557
		err = crypto_aead_setauthsize(
558
			aead, x->aalg->alg_trunc_len / 8);
559 560
		if (err)
			goto free_key;
L
Linus Torvalds 已提交
561
	}
562 563 564 565 566 567 568 569 570

	param->enckeylen = cpu_to_be32((x->ealg->alg_key_len + 7) / 8);
	memcpy(p, x->ealg->alg_key, (x->ealg->alg_key_len + 7) / 8);

	err = crypto_aead_setkey(aead, key, keylen);

free_key:
	kfree(key);

571 572 573 574 575 576 577 578 579 580 581 582 583
error:
	return err;
}

static int esp6_init_state(struct xfrm_state *x)
{
	struct crypto_aead *aead;
	u32 align;
	int err;

	if (x->encap)
		return -EINVAL;

584
	x->data = NULL;
585 586 587 588 589 590

	if (x->aead)
		err = esp_init_aead(x);
	else
		err = esp_init_authenc(x);

591
	if (err)
L
Linus Torvalds 已提交
592
		goto error;
593

594
	aead = x->data;
595

596 597
	x->props.header_len = sizeof(struct ip_esp_hdr) +
			      crypto_aead_ivsize(aead);
598 599
	switch (x->props.mode) {
	case XFRM_MODE_BEET:
600 601
		if (x->sel.family != AF_INET6)
			x->props.header_len += IPV4_BEET_PHMAXLEN +
602
					       (sizeof(struct ipv6hdr) - sizeof(struct iphdr));
603
		break;
604 605 606
	case XFRM_MODE_TRANSPORT:
		break;
	case XFRM_MODE_TUNNEL:
L
Linus Torvalds 已提交
607
		x->props.header_len += sizeof(struct ipv6hdr);
608
		break;
609 610 611
	default:
		goto error;
	}
612 613

	align = ALIGN(crypto_aead_blocksize(aead), 4);
614
	x->props.trailer_len = align + 1 + crypto_aead_authsize(aead);
L
Linus Torvalds 已提交
615 616

error:
617
	return err;
L
Linus Torvalds 已提交
618 619
}

620 621 622 623 624
static int esp6_rcv_cb(struct sk_buff *skb, int err)
{
	return 0;
}

625
static const struct xfrm_type esp6_type = {
L
Linus Torvalds 已提交
626
	.description	= "ESP6",
627 628
	.owner		= THIS_MODULE,
	.proto		= IPPROTO_ESP,
629
	.flags		= XFRM_TYPE_REPLAY_PROT,
L
Linus Torvalds 已提交
630 631
	.init_state	= esp6_init_state,
	.destructor	= esp6_destroy,
632
	.get_mtu	= esp6_get_mtu,
L
Linus Torvalds 已提交
633
	.input		= esp6_input,
634 635
	.output		= esp6_output,
	.hdr_offset	= xfrm6_find_1stfragopt,
L
Linus Torvalds 已提交
636 637
};

638 639 640
static struct xfrm6_protocol esp6_protocol = {
	.handler	=	xfrm6_rcv,
	.cb_handler	=	esp6_rcv_cb,
L
Linus Torvalds 已提交
641
	.err_handler	=	esp6_err,
642
	.priority	=	0,
L
Linus Torvalds 已提交
643 644 645 646 647
};

static int __init esp6_init(void)
{
	if (xfrm_register_type(&esp6_type, AF_INET6) < 0) {
648
		pr_info("%s: can't add xfrm type\n", __func__);
L
Linus Torvalds 已提交
649 650
		return -EAGAIN;
	}
651
	if (xfrm6_protocol_register(&esp6_protocol, IPPROTO_ESP) < 0) {
652
		pr_info("%s: can't add protocol\n", __func__);
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661
		xfrm_unregister_type(&esp6_type, AF_INET6);
		return -EAGAIN;
	}

	return 0;
}

static void __exit esp6_fini(void)
{
662
	if (xfrm6_protocol_deregister(&esp6_protocol, IPPROTO_ESP) < 0)
663
		pr_info("%s: can't remove protocol\n", __func__);
L
Linus Torvalds 已提交
664
	if (xfrm_unregister_type(&esp6_type, AF_INET6) < 0)
665
		pr_info("%s: can't remove xfrm type\n", __func__);
L
Linus Torvalds 已提交
666 667 668 669 670 671
}

module_init(esp6_init);
module_exit(esp6_fini);

MODULE_LICENSE("GPL");
672
MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ESP);