2 * Copyright (C)2002 USAGI/WIDE Project
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * Mitsuru KANDA @USAGI : IPv6 Support
21 * Kazunori MIYAZAWA @USAGI :
22 * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
24 * This file is derived from net/ipv4/esp.c
27 #include <linux/config.h>
28 #include <linux/module.h>
32 #include <asm/scatterlist.h>
33 #include <linux/crypto.h>
34 #include <linux/pfkeyv2.h>
35 #include <linux/random.h>
38 #include <linux/icmpv6.h>
40 static int esp6_output(struct sk_buff
*skb
)
44 struct dst_entry
*dst
= skb
->dst
;
45 struct xfrm_state
*x
= dst
->xfrm
;
46 struct ipv6hdr
*top_iph
;
47 struct ipv6_esp_hdr
*esph
;
48 struct crypto_tfm
*tfm
;
50 struct sk_buff
*trailer
;
57 hdr_len
= skb
->h
.raw
- skb
->data
+
58 sizeof(*esph
) + esp
->conf
.ivlen
;
60 /* Strip IP+ESP header. */
61 __skb_pull(skb
, hdr_len
);
63 /* Now skb is pure payload to encrypt */
66 /* Round to block size */
69 alen
= esp
->auth
.icv_trunc_len
;
71 blksize
= (crypto_tfm_alg_blocksize(tfm
) + 3) & ~3;
72 clen
= (clen
+ 2 + blksize
-1)&~(blksize
-1);
74 clen
= (clen
+ esp
->conf
.padlen
-1)&~(esp
->conf
.padlen
-1);
76 if ((nfrags
= skb_cow_data(skb
, clen
-skb
->len
+alen
, &trailer
)) < 0) {
83 for (i
=0; i
<clen
-skb
->len
- 2; i
++)
84 *(u8
*)(trailer
->tail
+ i
) = i
+1;
86 *(u8
*)(trailer
->tail
+ clen
-skb
->len
- 2) = (clen
- skb
->len
)-2;
87 pskb_put(skb
, trailer
, clen
- skb
->len
);
89 top_iph
= (struct ipv6hdr
*)__skb_push(skb
, hdr_len
);
90 esph
= (struct ipv6_esp_hdr
*)skb
->h
.raw
;
91 top_iph
->payload_len
= htons(skb
->len
+ alen
- sizeof(*top_iph
));
92 *(u8
*)(trailer
->tail
- 1) = *skb
->nh
.raw
;
93 *skb
->nh
.raw
= IPPROTO_ESP
;
95 esph
->spi
= x
->id
.spi
;
96 esph
->seq_no
= htonl(++x
->replay
.oseq
);
99 crypto_cipher_set_iv(tfm
, esp
->conf
.ivec
, crypto_tfm_alg_ivsize(tfm
));
102 struct scatterlist
*sg
= &esp
->sgbuf
[0];
104 if (unlikely(nfrags
> ESP_NUM_FAST_SG
)) {
105 sg
= kmalloc(sizeof(struct scatterlist
)*nfrags
, GFP_ATOMIC
);
109 skb_to_sgvec(skb
, sg
, esph
->enc_data
+esp
->conf
.ivlen
-skb
->data
, clen
);
110 crypto_cipher_encrypt(tfm
, sg
, sg
, clen
);
111 if (unlikely(sg
!= &esp
->sgbuf
[0]))
115 if (esp
->conf
.ivlen
) {
116 memcpy(esph
->enc_data
, esp
->conf
.ivec
, crypto_tfm_alg_ivsize(tfm
));
117 crypto_cipher_get_iv(tfm
, esp
->conf
.ivec
, crypto_tfm_alg_ivsize(tfm
));
120 if (esp
->auth
.icv_full_len
) {
121 esp
->auth
.icv(esp
, skb
, (u8
*)esph
-skb
->data
,
122 sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
+clen
, trailer
->tail
);
123 pskb_put(skb
, trailer
, alen
);
132 static int esp6_input(struct xfrm_state
*x
, struct xfrm_decap_state
*decap
, struct sk_buff
*skb
)
135 struct ipv6_esp_hdr
*esph
;
136 struct esp_data
*esp
= x
->data
;
137 struct sk_buff
*trailer
;
138 int blksize
= crypto_tfm_alg_blocksize(esp
->conf
.tfm
);
139 int alen
= esp
->auth
.icv_trunc_len
;
140 int elen
= skb
->len
- sizeof(struct ipv6_esp_hdr
) - esp
->conf
.ivlen
- alen
;
142 int hdr_len
= skb
->h
.raw
- skb
->nh
.raw
;
144 unsigned char *tmp_hdr
= NULL
;
147 if (!pskb_may_pull(skb
, sizeof(struct ipv6_esp_hdr
))) {
152 if (elen
<= 0 || (elen
& (blksize
-1))) {
157 tmp_hdr
= kmalloc(hdr_len
, GFP_ATOMIC
);
162 memcpy(tmp_hdr
, skb
->nh
.raw
, hdr_len
);
164 /* If integrity check is required, do this. */
165 if (esp
->auth
.icv_full_len
) {
166 u8 sum
[esp
->auth
.icv_full_len
];
169 esp
->auth
.icv(esp
, skb
, 0, skb
->len
-alen
, sum
);
171 if (skb_copy_bits(skb
, skb
->len
-alen
, sum1
, alen
))
174 if (unlikely(memcmp(sum
, sum1
, alen
))) {
175 x
->stats
.integrity_failed
++;
181 if ((nfrags
= skb_cow_data(skb
, 0, &trailer
)) < 0) {
186 skb
->ip_summed
= CHECKSUM_NONE
;
188 esph
= (struct ipv6_esp_hdr
*)skb
->data
;
191 /* Get ivec. This can be wrong, check against another impls. */
193 crypto_cipher_set_iv(esp
->conf
.tfm
, esph
->enc_data
, crypto_tfm_alg_ivsize(esp
->conf
.tfm
));
197 struct scatterlist
*sg
= &esp
->sgbuf
[0];
200 if (unlikely(nfrags
> ESP_NUM_FAST_SG
)) {
201 sg
= kmalloc(sizeof(struct scatterlist
)*nfrags
, GFP_ATOMIC
);
207 skb_to_sgvec(skb
, sg
, sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
, elen
);
208 crypto_cipher_decrypt(esp
->conf
.tfm
, sg
, sg
, elen
);
209 if (unlikely(sg
!= &esp
->sgbuf
[0]))
212 if (skb_copy_bits(skb
, skb
->len
-alen
-2, nexthdr
, 2))
216 if (padlen
+2 >= elen
) {
218 printk(KERN_WARNING
"ipsec esp packet is garbage padlen=%d, elen=%d\n", padlen
+2, elen
));
222 /* ... check padding bits here. Silly. :-) */
224 pskb_trim(skb
, skb
->len
- alen
- padlen
- 2);
225 skb
->h
.raw
= skb_pull(skb
, sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
);
226 skb
->nh
.raw
+= sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
;
227 memcpy(skb
->nh
.raw
, tmp_hdr
, hdr_len
);
228 skb
->nh
.ipv6h
->payload_len
= htons(skb
->len
- sizeof(struct ipv6hdr
));
238 static u32
esp6_get_max_size(struct xfrm_state
*x
, int mtu
)
240 struct esp_data
*esp
= x
->data
;
241 u32 blksize
= crypto_tfm_alg_blocksize(esp
->conf
.tfm
);
244 mtu
= (mtu
+ 2 + blksize
-1)&~(blksize
-1);
246 /* The worst case. */
249 if (esp
->conf
.padlen
)
250 mtu
= (mtu
+ esp
->conf
.padlen
-1)&~(esp
->conf
.padlen
-1);
252 return mtu
+ x
->props
.header_len
+ esp
->auth
.icv_full_len
;
255 static void esp6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
256 int type
, int code
, int offset
, __u32 info
)
258 struct ipv6hdr
*iph
= (struct ipv6hdr
*)skb
->data
;
259 struct ipv6_esp_hdr
*esph
= (struct ipv6_esp_hdr
*)(skb
->data
+offset
);
260 struct xfrm_state
*x
;
262 if (type
!= ICMPV6_DEST_UNREACH
&&
263 type
!= ICMPV6_PKT_TOOBIG
)
266 x
= xfrm_state_lookup((xfrm_address_t
*)&iph
->daddr
, esph
->spi
, IPPROTO_ESP
, AF_INET6
);
269 printk(KERN_DEBUG
"pmtu discovery on SA ESP/%08x/"
270 "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
271 ntohl(esph
->spi
), NIP6(iph
->daddr
));
275 static void esp6_destroy(struct xfrm_state
*x
)
277 struct esp_data
*esp
= x
->data
;
283 crypto_free_tfm(esp
->conf
.tfm
);
284 esp
->conf
.tfm
= NULL
;
286 if (esp
->conf
.ivec
) {
287 kfree(esp
->conf
.ivec
);
288 esp
->conf
.ivec
= NULL
;
291 crypto_free_tfm(esp
->auth
.tfm
);
292 esp
->auth
.tfm
= NULL
;
294 if (esp
->auth
.work_icv
) {
295 kfree(esp
->auth
.work_icv
);
296 esp
->auth
.work_icv
= NULL
;
301 static int esp6_init_state(struct xfrm_state
*x
, void *args
)
303 struct esp_data
*esp
= NULL
;
305 /* null auth and encryption can have zero length keys */
307 if (x
->aalg
->alg_key_len
> 512)
316 esp
= kmalloc(sizeof(*esp
), GFP_KERNEL
);
320 memset(esp
, 0, sizeof(*esp
));
323 struct xfrm_algo_desc
*aalg_desc
;
325 esp
->auth
.key
= x
->aalg
->alg_key
;
326 esp
->auth
.key_len
= (x
->aalg
->alg_key_len
+7)/8;
327 esp
->auth
.tfm
= crypto_alloc_tfm(x
->aalg
->alg_name
, 0);
328 if (esp
->auth
.tfm
== NULL
)
330 esp
->auth
.icv
= esp_hmac_digest
;
332 aalg_desc
= xfrm_aalg_get_byname(x
->aalg
->alg_name
);
335 if (aalg_desc
->uinfo
.auth
.icv_fullbits
/8 !=
336 crypto_tfm_alg_digestsize(esp
->auth
.tfm
)) {
337 printk(KERN_INFO
"ESP: %s digestsize %u != %hu\n",
339 crypto_tfm_alg_digestsize(esp
->auth
.tfm
),
340 aalg_desc
->uinfo
.auth
.icv_fullbits
/8);
344 esp
->auth
.icv_full_len
= aalg_desc
->uinfo
.auth
.icv_fullbits
/8;
345 esp
->auth
.icv_trunc_len
= aalg_desc
->uinfo
.auth
.icv_truncbits
/8;
347 esp
->auth
.work_icv
= kmalloc(esp
->auth
.icv_full_len
, GFP_KERNEL
);
348 if (!esp
->auth
.work_icv
)
351 esp
->conf
.key
= x
->ealg
->alg_key
;
352 esp
->conf
.key_len
= (x
->ealg
->alg_key_len
+7)/8;
353 if (x
->props
.ealgo
== SADB_EALG_NULL
)
354 esp
->conf
.tfm
= crypto_alloc_tfm(x
->ealg
->alg_name
, CRYPTO_TFM_MODE_ECB
);
356 esp
->conf
.tfm
= crypto_alloc_tfm(x
->ealg
->alg_name
, CRYPTO_TFM_MODE_CBC
);
357 if (esp
->conf
.tfm
== NULL
)
359 esp
->conf
.ivlen
= crypto_tfm_alg_ivsize(esp
->conf
.tfm
);
360 esp
->conf
.padlen
= 0;
361 if (esp
->conf
.ivlen
) {
362 esp
->conf
.ivec
= kmalloc(esp
->conf
.ivlen
, GFP_KERNEL
);
363 if (unlikely(esp
->conf
.ivec
== NULL
))
365 get_random_bytes(esp
->conf
.ivec
, esp
->conf
.ivlen
);
367 crypto_cipher_setkey(esp
->conf
.tfm
, esp
->conf
.key
, esp
->conf
.key_len
);
368 x
->props
.header_len
= sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
;
370 x
->props
.header_len
+= sizeof(struct ipv6hdr
);
377 crypto_free_tfm(esp
->auth
.tfm
);
378 if (esp
->auth
.work_icv
)
379 kfree(esp
->auth
.work_icv
);
381 crypto_free_tfm(esp
->conf
.tfm
);
387 static struct xfrm_type esp6_type
=
389 .description
= "ESP6",
390 .owner
= THIS_MODULE
,
391 .proto
= IPPROTO_ESP
,
392 .init_state
= esp6_init_state
,
393 .destructor
= esp6_destroy
,
394 .get_max_size
= esp6_get_max_size
,
396 .output
= esp6_output
399 static struct inet6_protocol esp6_protocol
= {
400 .handler
= xfrm6_rcv
,
401 .err_handler
= esp6_err
,
402 .flags
= INET6_PROTO_NOPOLICY
,
405 static int __init
esp6_init(void)
407 if (xfrm_register_type(&esp6_type
, AF_INET6
) < 0) {
408 printk(KERN_INFO
"ipv6 esp init: can't add xfrm type\n");
411 if (inet6_add_protocol(&esp6_protocol
, IPPROTO_ESP
) < 0) {
412 printk(KERN_INFO
"ipv6 esp init: can't add protocol\n");
413 xfrm_unregister_type(&esp6_type
, AF_INET6
);
420 static void __exit
esp6_fini(void)
422 if (inet6_del_protocol(&esp6_protocol
, IPPROTO_ESP
) < 0)
423 printk(KERN_INFO
"ipv6 esp close: can't remove protocol\n");
424 if (xfrm_unregister_type(&esp6_type
, AF_INET6
) < 0)
425 printk(KERN_INFO
"ipv6 esp close: can't remove xfrm type\n");
428 module_init(esp6_init
);
429 module_exit(esp6_fini
);
431 MODULE_LICENSE("GPL");