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