1 /* 2 * Copyright (C)2002 USAGI/WIDE Project 3 * 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. 8 * 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. 13 * 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 17 * 18 * Authors 19 * 20 * Mitsuru KANDA @USAGI : IPv6 Support 21 * Kazunori MIYAZAWA @USAGI : 22 * Kunihiro Ishiguro <kunihiro@ipinfusion.com> 23 * 24 * This file is derived from net/ipv4/ah.c. 25 */ 26 27 #include <linux/config.h> 28 #include <linux/module.h> 29 #include <net/ip.h> 30 #include <net/ah.h> 31 #include <linux/crypto.h> 32 #include <linux/pfkeyv2.h> 33 #include <linux/string.h> 34 #include <net/icmp.h> 35 #include <net/ipv6.h> 36 #include <net/protocol.h> 37 #include <net/xfrm.h> 38 #include <asm/scatterlist.h> 39 40 static int zero_out_mutable_opts(struct ipv6_opt_hdr *opthdr) 41 { 42 u8 *opt = (u8 *)opthdr; 43 int len = ipv6_optlen(opthdr); 44 int off = 0; 45 int optlen = 0; 46 47 off += 2; 48 len -= 2; 49 50 while (len > 0) { 51 52 switch (opt[off]) { 53 54 case IPV6_TLV_PAD0: 55 optlen = 1; 56 break; 57 default: 58 if (len < 2) 59 goto bad; 60 optlen = opt[off+1]+2; 61 if (len < optlen) 62 goto bad; 63 if (opt[off] & 0x20) 64 memset(&opt[off+2], 0, opt[off+1]); 65 break; 66 } 67 68 off += optlen; 69 len -= optlen; 70 } 71 if (len == 0) 72 return 1; 73 74 bad: 75 return 0; 76 } 77 78 /** 79 * ipv6_rearrange_rthdr - rearrange IPv6 routing header 80 * @iph: IPv6 header 81 * @rthdr: routing header 82 * 83 * Rearrange the destination address in @iph and the addresses in @rthdr 84 * so that they appear in the order they will at the final destination. 85 * See Appendix A2 of RFC 2402 for details. 86 */ 87 static void ipv6_rearrange_rthdr(struct ipv6hdr *iph, struct ipv6_rt_hdr *rthdr) 88 { 89 int segments, segments_left; 90 struct in6_addr *addrs; 91 struct in6_addr final_addr; 92 93 segments_left = rthdr->segments_left; 94 if (segments_left == 0) 95 return; 96 rthdr->segments_left = 0; 97 98 /* The value of rthdr->hdrlen has been verified either by the system 99 * call if it is locally generated, or by ipv6_rthdr_rcv() for incoming 100 * packets. So we can assume that it is even and that segments is 101 * greater than or equal to segments_left. 102 * 103 * For the same reason we can assume that this option is of type 0. 104 */ 105 segments = rthdr->hdrlen >> 1; 106 107 addrs = ((struct rt0_hdr *)rthdr)->addr; 108 ipv6_addr_copy(&final_addr, addrs + segments - 1); 109 110 addrs += segments - segments_left; 111 memmove(addrs + 1, addrs, (segments_left - 1) * sizeof(*addrs)); 112 113 ipv6_addr_copy(addrs, &iph->daddr); 114 ipv6_addr_copy(&iph->daddr, &final_addr); 115 } 116 117 static int ipv6_clear_mutable_options(struct ipv6hdr *iph, int len) 118 { 119 union { 120 struct ipv6hdr *iph; 121 struct ipv6_opt_hdr *opth; 122 struct ipv6_rt_hdr *rth; 123 char *raw; 124 } exthdr = { .iph = iph }; 125 char *end = exthdr.raw + len; 126 int nexthdr = iph->nexthdr; 127 128 exthdr.iph++; 129 130 while (exthdr.raw < end) { 131 switch (nexthdr) { 132 case NEXTHDR_HOP: 133 case NEXTHDR_DEST: 134 if (!zero_out_mutable_opts(exthdr.opth)) { 135 LIMIT_NETDEBUG( 136 KERN_WARNING "overrun %sopts\n", 137 nexthdr == NEXTHDR_HOP ? 138 "hop" : "dest"); 139 return -EINVAL; 140 } 141 break; 142 143 case NEXTHDR_ROUTING: 144 ipv6_rearrange_rthdr(iph, exthdr.rth); 145 break; 146 147 default : 148 return 0; 149 } 150 151 nexthdr = exthdr.opth->nexthdr; 152 exthdr.raw += ipv6_optlen(exthdr.opth); 153 } 154 155 return 0; 156 } 157 158 static int ah6_output(struct xfrm_state *x, struct sk_buff *skb) 159 { 160 int err; 161 int extlen; 162 struct ipv6hdr *top_iph; 163 struct ip_auth_hdr *ah; 164 struct ah_data *ahp; 165 u8 nexthdr; 166 char tmp_base[8]; 167 struct { 168 struct in6_addr daddr; 169 char hdrs[0]; 170 } *tmp_ext; 171 172 top_iph = (struct ipv6hdr *)skb->data; 173 top_iph->payload_len = htons(skb->len - sizeof(*top_iph)); 174 175 nexthdr = *skb->nh.raw; 176 *skb->nh.raw = IPPROTO_AH; 177 178 /* When there are no extension headers, we only need to save the first 179 * 8 bytes of the base IP header. 180 */ 181 memcpy(tmp_base, top_iph, sizeof(tmp_base)); 182 183 tmp_ext = NULL; 184 extlen = skb->h.raw - (unsigned char *)(top_iph + 1); 185 if (extlen) { 186 extlen += sizeof(*tmp_ext); 187 tmp_ext = kmalloc(extlen, GFP_ATOMIC); 188 if (!tmp_ext) { 189 err = -ENOMEM; 190 goto error; 191 } 192 memcpy(tmp_ext, &top_iph->daddr, extlen); 193 err = ipv6_clear_mutable_options(top_iph, 194 extlen - sizeof(*tmp_ext) + 195 sizeof(*top_iph)); 196 if (err) 197 goto error_free_iph; 198 } 199 200 ah = (struct ip_auth_hdr *)skb->h.raw; 201 ah->nexthdr = nexthdr; 202 203 top_iph->priority = 0; 204 top_iph->flow_lbl[0] = 0; 205 top_iph->flow_lbl[1] = 0; 206 top_iph->flow_lbl[2] = 0; 207 top_iph->hop_limit = 0; 208 209 ahp = x->data; 210 ah->hdrlen = (XFRM_ALIGN8(sizeof(struct ipv6_auth_hdr) + 211 ahp->icv_trunc_len) >> 2) - 2; 212 213 ah->reserved = 0; 214 ah->spi = x->id.spi; 215 ah->seq_no = htonl(++x->replay.oseq); 216 ahp->icv(ahp, skb, ah->auth_data); 217 218 err = 0; 219 220 memcpy(top_iph, tmp_base, sizeof(tmp_base)); 221 if (tmp_ext) { 222 memcpy(&top_iph->daddr, tmp_ext, extlen); 223 error_free_iph: 224 kfree(tmp_ext); 225 } 226 227 error: 228 return err; 229 } 230 231 static int ah6_input(struct xfrm_state *x, struct xfrm_decap_state *decap, struct sk_buff *skb) 232 { 233 /* 234 * Before process AH 235 * [IPv6][Ext1][Ext2][AH][Dest][Payload] 236 * |<-------------->| hdr_len 237 * 238 * To erase AH: 239 * Keeping copy of cleared headers. After AH processing, 240 * Moving the pointer of skb->nh.raw by using skb_pull as long as AH 241 * header length. Then copy back the copy as long as hdr_len 242 * If destination header following AH exists, copy it into after [Ext2]. 243 * 244 * |<>|[IPv6][Ext1][Ext2][Dest][Payload] 245 * There is offset of AH before IPv6 header after the process. 246 */ 247 248 struct ipv6_auth_hdr *ah; 249 struct ah_data *ahp; 250 unsigned char *tmp_hdr = NULL; 251 u16 hdr_len; 252 u16 ah_hlen; 253 int nexthdr; 254 255 if (!pskb_may_pull(skb, sizeof(struct ip_auth_hdr))) 256 goto out; 257 258 /* We are going to _remove_ AH header to keep sockets happy, 259 * so... Later this can change. */ 260 if (skb_cloned(skb) && 261 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) 262 goto out; 263 264 hdr_len = skb->data - skb->nh.raw; 265 ah = (struct ipv6_auth_hdr*)skb->data; 266 ahp = x->data; 267 nexthdr = ah->nexthdr; 268 ah_hlen = (ah->hdrlen + 2) << 2; 269 270 if (ah_hlen != XFRM_ALIGN8(sizeof(struct ipv6_auth_hdr) + ahp->icv_full_len) && 271 ah_hlen != XFRM_ALIGN8(sizeof(struct ipv6_auth_hdr) + ahp->icv_trunc_len)) 272 goto out; 273 274 if (!pskb_may_pull(skb, ah_hlen)) 275 goto out; 276 277 tmp_hdr = kmalloc(hdr_len, GFP_ATOMIC); 278 if (!tmp_hdr) 279 goto out; 280 memcpy(tmp_hdr, skb->nh.raw, hdr_len); 281 if (ipv6_clear_mutable_options(skb->nh.ipv6h, hdr_len)) 282 goto out; 283 skb->nh.ipv6h->priority = 0; 284 skb->nh.ipv6h->flow_lbl[0] = 0; 285 skb->nh.ipv6h->flow_lbl[1] = 0; 286 skb->nh.ipv6h->flow_lbl[2] = 0; 287 skb->nh.ipv6h->hop_limit = 0; 288 289 { 290 u8 auth_data[MAX_AH_AUTH_LEN]; 291 292 memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len); 293 memset(ah->auth_data, 0, ahp->icv_trunc_len); 294 skb_push(skb, skb->data - skb->nh.raw); 295 ahp->icv(ahp, skb, ah->auth_data); 296 if (memcmp(ah->auth_data, auth_data, ahp->icv_trunc_len)) { 297 LIMIT_NETDEBUG(KERN_WARNING "ipsec ah authentication error\n"); 298 x->stats.integrity_failed++; 299 goto free_out; 300 } 301 } 302 303 skb->nh.raw = skb_pull(skb, ah_hlen); 304 memcpy(skb->nh.raw, tmp_hdr, hdr_len); 305 skb->nh.ipv6h->payload_len = htons(skb->len - sizeof(struct ipv6hdr)); 306 skb_pull(skb, hdr_len); 307 skb->h.raw = skb->data; 308 309 310 kfree(tmp_hdr); 311 312 return nexthdr; 313 314 free_out: 315 kfree(tmp_hdr); 316 out: 317 return -EINVAL; 318 } 319 320 static void ah6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, 321 int type, int code, int offset, __u32 info) 322 { 323 struct ipv6hdr *iph = (struct ipv6hdr*)skb->data; 324 struct ip_auth_hdr *ah = (struct ip_auth_hdr*)(skb->data+offset); 325 struct xfrm_state *x; 326 327 if (type != ICMPV6_DEST_UNREACH && 328 type != ICMPV6_PKT_TOOBIG) 329 return; 330 331 x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, ah->spi, IPPROTO_AH, AF_INET6); 332 if (!x) 333 return; 334 335 NETDEBUG(KERN_DEBUG "pmtu discovery on SA AH/%08x/" 336 "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", 337 ntohl(ah->spi), NIP6(iph->daddr)); 338 339 xfrm_state_put(x); 340 } 341 342 static int ah6_init_state(struct xfrm_state *x) 343 { 344 struct ah_data *ahp = NULL; 345 struct xfrm_algo_desc *aalg_desc; 346 347 if (!x->aalg) 348 goto error; 349 350 /* null auth can use a zero length key */ 351 if (x->aalg->alg_key_len > 512) 352 goto error; 353 354 if (x->encap) 355 goto error; 356 357 ahp = kmalloc(sizeof(*ahp), GFP_KERNEL); 358 if (ahp == NULL) 359 return -ENOMEM; 360 361 memset(ahp, 0, sizeof(*ahp)); 362 363 ahp->key = x->aalg->alg_key; 364 ahp->key_len = (x->aalg->alg_key_len+7)/8; 365 ahp->tfm = crypto_alloc_tfm(x->aalg->alg_name, 0); 366 if (!ahp->tfm) 367 goto error; 368 ahp->icv = ah_hmac_digest; 369 370 /* 371 * Lookup the algorithm description maintained by xfrm_algo, 372 * verify crypto transform properties, and store information 373 * we need for AH processing. This lookup cannot fail here 374 * after a successful crypto_alloc_tfm(). 375 */ 376 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); 377 BUG_ON(!aalg_desc); 378 379 if (aalg_desc->uinfo.auth.icv_fullbits/8 != 380 crypto_tfm_alg_digestsize(ahp->tfm)) { 381 printk(KERN_INFO "AH: %s digestsize %u != %hu\n", 382 x->aalg->alg_name, crypto_tfm_alg_digestsize(ahp->tfm), 383 aalg_desc->uinfo.auth.icv_fullbits/8); 384 goto error; 385 } 386 387 ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8; 388 ahp->icv_trunc_len = aalg_desc->uinfo.auth.icv_truncbits/8; 389 390 BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN); 391 392 ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL); 393 if (!ahp->work_icv) 394 goto error; 395 396 x->props.header_len = XFRM_ALIGN8(sizeof(struct ipv6_auth_hdr) + ahp->icv_trunc_len); 397 if (x->props.mode) 398 x->props.header_len += sizeof(struct ipv6hdr); 399 x->data = ahp; 400 401 return 0; 402 403 error: 404 if (ahp) { 405 kfree(ahp->work_icv); 406 crypto_free_tfm(ahp->tfm); 407 kfree(ahp); 408 } 409 return -EINVAL; 410 } 411 412 static void ah6_destroy(struct xfrm_state *x) 413 { 414 struct ah_data *ahp = x->data; 415 416 if (!ahp) 417 return; 418 419 kfree(ahp->work_icv); 420 ahp->work_icv = NULL; 421 crypto_free_tfm(ahp->tfm); 422 ahp->tfm = NULL; 423 kfree(ahp); 424 } 425 426 static struct xfrm_type ah6_type = 427 { 428 .description = "AH6", 429 .owner = THIS_MODULE, 430 .proto = IPPROTO_AH, 431 .init_state = ah6_init_state, 432 .destructor = ah6_destroy, 433 .input = ah6_input, 434 .output = ah6_output 435 }; 436 437 static struct inet6_protocol ah6_protocol = { 438 .handler = xfrm6_rcv, 439 .err_handler = ah6_err, 440 .flags = INET6_PROTO_NOPOLICY, 441 }; 442 443 static int __init ah6_init(void) 444 { 445 if (xfrm_register_type(&ah6_type, AF_INET6) < 0) { 446 printk(KERN_INFO "ipv6 ah init: can't add xfrm type\n"); 447 return -EAGAIN; 448 } 449 450 if (inet6_add_protocol(&ah6_protocol, IPPROTO_AH) < 0) { 451 printk(KERN_INFO "ipv6 ah init: can't add protocol\n"); 452 xfrm_unregister_type(&ah6_type, AF_INET6); 453 return -EAGAIN; 454 } 455 456 return 0; 457 } 458 459 static void __exit ah6_fini(void) 460 { 461 if (inet6_del_protocol(&ah6_protocol, IPPROTO_AH) < 0) 462 printk(KERN_INFO "ipv6 ah close: can't remove protocol\n"); 463 464 if (xfrm_unregister_type(&ah6_type, AF_INET6) < 0) 465 printk(KERN_INFO "ipv6 ah close: can't remove xfrm type\n"); 466 467 } 468 469 module_init(ah6_init); 470 module_exit(ah6_fini); 471 472 MODULE_LICENSE("GPL"); 473