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/err.h>
28 #include <linux/module.h>
32 #include <asm/scatterlist.h>
33 #include <linux/crypto.h>
34 #include <linux/kernel.h>
35 #include <linux/pfkeyv2.h>
36 #include <linux/random.h>
37 #include <linux/spinlock.h>
40 #include <net/protocol.h>
41 #include <linux/icmpv6.h>
43 static int esp6_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
46 struct ipv6hdr
*top_iph
;
47 struct ipv6_esp_hdr
*esph
;
48 struct crypto_blkcipher
*tfm
;
49 struct blkcipher_desc desc
;
50 struct sk_buff
*trailer
;
56 struct esp_data
*esp
= x
->data
;
58 /* skb is pure payload to encrypt */
61 /* Round to block size */
64 alen
= esp
->auth
.icv_trunc_len
;
68 blksize
= ALIGN(crypto_blkcipher_blocksize(tfm
), 4);
69 clen
= ALIGN(clen
+ 2, blksize
);
71 clen
= ALIGN(clen
, esp
->conf
.padlen
);
73 if ((nfrags
= skb_cow_data(skb
, clen
-skb
->len
+alen
, &trailer
)) < 0) {
78 tail
= skb_tail_pointer(trailer
);
81 for (i
=0; i
<clen
-skb
->len
- 2; i
++)
84 tail
[clen
-skb
->len
- 2] = (clen
- skb
->len
) - 2;
85 pskb_put(skb
, trailer
, clen
- skb
->len
);
87 skb_push(skb
, -skb_network_offset(skb
));
88 top_iph
= ipv6_hdr(skb
);
89 esph
= (struct ipv6_esp_hdr
*)skb_transport_header(skb
);
90 top_iph
->payload_len
= htons(skb
->len
+ alen
- sizeof(*top_iph
));
91 *(skb_tail_pointer(trailer
) - 1) = *skb_mac_header(skb
);
92 *skb_mac_header(skb
) = IPPROTO_ESP
;
94 esph
->spi
= x
->id
.spi
;
95 esph
->seq_no
= htonl(XFRM_SKB_CB(skb
)->seq
);
97 spin_lock_bh(&x
->lock
);
99 if (esp
->conf
.ivlen
) {
100 if (unlikely(!esp
->conf
.ivinitted
)) {
101 get_random_bytes(esp
->conf
.ivec
, esp
->conf
.ivlen
);
102 esp
->conf
.ivinitted
= 1;
104 crypto_blkcipher_set_iv(tfm
, esp
->conf
.ivec
, esp
->conf
.ivlen
);
108 struct scatterlist
*sg
= &esp
->sgbuf
[0];
110 if (unlikely(nfrags
> ESP_NUM_FAST_SG
)) {
111 sg
= kmalloc(sizeof(struct scatterlist
)*nfrags
, GFP_ATOMIC
);
115 skb_to_sgvec(skb
, sg
, esph
->enc_data
+esp
->conf
.ivlen
-skb
->data
, clen
);
116 err
= crypto_blkcipher_encrypt(&desc
, sg
, sg
, clen
);
117 if (unlikely(sg
!= &esp
->sgbuf
[0]))
124 if (esp
->conf
.ivlen
) {
125 memcpy(esph
->enc_data
, esp
->conf
.ivec
, esp
->conf
.ivlen
);
126 crypto_blkcipher_get_iv(tfm
, esp
->conf
.ivec
, esp
->conf
.ivlen
);
129 if (esp
->auth
.icv_full_len
) {
130 err
= esp_mac_digest(esp
, skb
, (u8
*)esph
- skb
->data
,
131 sizeof(*esph
) + esp
->conf
.ivlen
+ clen
);
132 memcpy(pskb_put(skb
, trailer
, alen
), esp
->auth
.work_icv
, alen
);
136 spin_unlock_bh(&x
->lock
);
142 static int esp6_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
145 struct ipv6_esp_hdr
*esph
;
146 struct esp_data
*esp
= x
->data
;
147 struct crypto_blkcipher
*tfm
= esp
->conf
.tfm
;
148 struct blkcipher_desc desc
= { .tfm
= tfm
};
149 struct sk_buff
*trailer
;
150 int blksize
= ALIGN(crypto_blkcipher_blocksize(tfm
), 4);
151 int alen
= esp
->auth
.icv_trunc_len
;
152 int elen
= skb
->len
- sizeof(struct ipv6_esp_hdr
) - esp
->conf
.ivlen
- alen
;
153 int hdr_len
= skb_network_header_len(skb
);
157 if (!pskb_may_pull(skb
, sizeof(struct ipv6_esp_hdr
))) {
162 if (elen
<= 0 || (elen
& (blksize
-1))) {
167 /* If integrity check is required, do this. */
168 if (esp
->auth
.icv_full_len
) {
171 ret
= esp_mac_digest(esp
, skb
, 0, skb
->len
- alen
);
175 if (skb_copy_bits(skb
, skb
->len
- alen
, sum
, alen
))
178 if (unlikely(memcmp(esp
->auth
.work_icv
, sum
, alen
))) {
179 x
->stats
.integrity_failed
++;
185 if ((nfrags
= skb_cow_data(skb
, 0, &trailer
)) < 0) {
190 skb
->ip_summed
= CHECKSUM_NONE
;
192 esph
= (struct ipv6_esp_hdr
*)skb
->data
;
195 /* Get ivec. This can be wrong, check against another impls. */
197 crypto_blkcipher_set_iv(tfm
, esph
->enc_data
, esp
->conf
.ivlen
);
201 struct scatterlist
*sg
= &esp
->sgbuf
[0];
204 if (unlikely(nfrags
> ESP_NUM_FAST_SG
)) {
205 sg
= kmalloc(sizeof(struct scatterlist
)*nfrags
, GFP_ATOMIC
);
211 skb_to_sgvec(skb
, sg
, sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
, elen
);
212 ret
= crypto_blkcipher_decrypt(&desc
, sg
, sg
, elen
);
213 if (unlikely(sg
!= &esp
->sgbuf
[0]))
218 if (skb_copy_bits(skb
, skb
->len
-alen
-2, nexthdr
, 2))
222 if (padlen
+2 >= elen
) {
223 LIMIT_NETDEBUG(KERN_WARNING
"ipsec esp packet is garbage padlen=%d, elen=%d\n", padlen
+2, elen
);
227 /* ... check padding bits here. Silly. :-) */
229 pskb_trim(skb
, skb
->len
- alen
- padlen
- 2);
233 __skb_pull(skb
, sizeof(*esph
) + esp
->conf
.ivlen
);
234 skb_set_transport_header(skb
, -hdr_len
);
239 static u32
esp6_get_mtu(struct xfrm_state
*x
, int mtu
)
241 struct esp_data
*esp
= x
->data
;
242 u32 blksize
= ALIGN(crypto_blkcipher_blocksize(esp
->conf
.tfm
), 4);
243 u32 align
= max_t(u32
, blksize
, esp
->conf
.padlen
);
246 mtu
-= x
->props
.header_len
+ esp
->auth
.icv_trunc_len
;
247 rem
= mtu
& (align
- 1);
250 if (x
->props
.mode
!= XFRM_MODE_TUNNEL
) {
251 u32 padsize
= ((blksize
- 1) & 7) + 1;
252 mtu
-= blksize
- padsize
;
253 mtu
+= min_t(u32
, blksize
- padsize
, rem
);
259 static void esp6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
260 int type
, int code
, int offset
, __be32 info
)
262 struct ipv6hdr
*iph
= (struct ipv6hdr
*)skb
->data
;
263 struct ipv6_esp_hdr
*esph
= (struct ipv6_esp_hdr
*)(skb
->data
+offset
);
264 struct xfrm_state
*x
;
266 if (type
!= ICMPV6_DEST_UNREACH
&&
267 type
!= ICMPV6_PKT_TOOBIG
)
270 x
= xfrm_state_lookup((xfrm_address_t
*)&iph
->daddr
, esph
->spi
, IPPROTO_ESP
, AF_INET6
);
273 printk(KERN_DEBUG
"pmtu discovery on SA ESP/%08x/" NIP6_FMT
"\n",
274 ntohl(esph
->spi
), NIP6(iph
->daddr
));
278 static void esp6_destroy(struct xfrm_state
*x
)
280 struct esp_data
*esp
= x
->data
;
285 crypto_free_blkcipher(esp
->conf
.tfm
);
286 esp
->conf
.tfm
= NULL
;
287 kfree(esp
->conf
.ivec
);
288 esp
->conf
.ivec
= NULL
;
289 crypto_free_hash(esp
->auth
.tfm
);
290 esp
->auth
.tfm
= NULL
;
291 kfree(esp
->auth
.work_icv
);
292 esp
->auth
.work_icv
= NULL
;
296 static int esp6_init_state(struct xfrm_state
*x
)
298 struct esp_data
*esp
= NULL
;
299 struct crypto_blkcipher
*tfm
;
307 esp
= kzalloc(sizeof(*esp
), GFP_KERNEL
);
312 struct xfrm_algo_desc
*aalg_desc
;
313 struct crypto_hash
*hash
;
315 hash
= crypto_alloc_hash(x
->aalg
->alg_name
, 0,
320 esp
->auth
.tfm
= hash
;
321 if (crypto_hash_setkey(hash
, x
->aalg
->alg_key
,
322 (x
->aalg
->alg_key_len
+ 7) / 8))
325 aalg_desc
= xfrm_aalg_get_byname(x
->aalg
->alg_name
, 0);
328 if (aalg_desc
->uinfo
.auth
.icv_fullbits
/8 !=
329 crypto_hash_digestsize(hash
)) {
330 NETDEBUG(KERN_INFO
"ESP: %s digestsize %u != %hu\n",
332 crypto_hash_digestsize(hash
),
333 aalg_desc
->uinfo
.auth
.icv_fullbits
/8);
337 esp
->auth
.icv_full_len
= aalg_desc
->uinfo
.auth
.icv_fullbits
/8;
338 esp
->auth
.icv_trunc_len
= aalg_desc
->uinfo
.auth
.icv_truncbits
/8;
340 esp
->auth
.work_icv
= kmalloc(esp
->auth
.icv_full_len
, GFP_KERNEL
);
341 if (!esp
->auth
.work_icv
)
344 tfm
= crypto_alloc_blkcipher(x
->ealg
->alg_name
, 0, CRYPTO_ALG_ASYNC
);
348 esp
->conf
.ivlen
= crypto_blkcipher_ivsize(tfm
);
349 esp
->conf
.padlen
= 0;
350 if (esp
->conf
.ivlen
) {
351 esp
->conf
.ivec
= kmalloc(esp
->conf
.ivlen
, GFP_KERNEL
);
352 if (unlikely(esp
->conf
.ivec
== NULL
))
354 esp
->conf
.ivinitted
= 0;
356 if (crypto_blkcipher_setkey(tfm
, x
->ealg
->alg_key
,
357 (x
->ealg
->alg_key_len
+ 7) / 8))
359 x
->props
.header_len
= sizeof(struct ipv6_esp_hdr
) + esp
->conf
.ivlen
;
360 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
361 x
->props
.header_len
+= sizeof(struct ipv6hdr
);
372 static struct xfrm_type esp6_type
=
374 .description
= "ESP6",
375 .owner
= THIS_MODULE
,
376 .proto
= IPPROTO_ESP
,
377 .flags
= XFRM_TYPE_REPLAY_PROT
,
378 .init_state
= esp6_init_state
,
379 .destructor
= esp6_destroy
,
380 .get_mtu
= esp6_get_mtu
,
382 .output
= esp6_output
,
383 .hdr_offset
= xfrm6_find_1stfragopt
,
386 static struct inet6_protocol esp6_protocol
= {
387 .handler
= xfrm6_rcv
,
388 .err_handler
= esp6_err
,
389 .flags
= INET6_PROTO_NOPOLICY
,
392 static int __init
esp6_init(void)
394 if (xfrm_register_type(&esp6_type
, AF_INET6
) < 0) {
395 printk(KERN_INFO
"ipv6 esp init: can't add xfrm type\n");
398 if (inet6_add_protocol(&esp6_protocol
, IPPROTO_ESP
) < 0) {
399 printk(KERN_INFO
"ipv6 esp init: can't add protocol\n");
400 xfrm_unregister_type(&esp6_type
, AF_INET6
);
407 static void __exit
esp6_fini(void)
409 if (inet6_del_protocol(&esp6_protocol
, IPPROTO_ESP
) < 0)
410 printk(KERN_INFO
"ipv6 esp close: can't remove protocol\n");
411 if (xfrm_unregister_type(&esp6_type
, AF_INET6
) < 0)
412 printk(KERN_INFO
"ipv6 esp close: can't remove xfrm type\n");
415 module_init(esp6_init
);
416 module_exit(esp6_fini
);
418 MODULE_LICENSE("GPL");
419 MODULE_ALIAS_XFRM_TYPE(AF_INET6
, XFRM_PROTO_ESP
);