1 #include <crypto/hash.h> 2 #include <linux/err.h> 3 #include <linux/module.h> 4 #include <linux/slab.h> 5 #include <net/ip.h> 6 #include <net/xfrm.h> 7 #include <net/ah.h> 8 #include <linux/crypto.h> 9 #include <linux/pfkeyv2.h> 10 #include <linux/scatterlist.h> 11 #include <net/icmp.h> 12 #include <net/protocol.h> 13 14 struct ah_skb_cb { 15 struct xfrm_skb_cb xfrm; 16 void *tmp; 17 }; 18 19 #define AH_SKB_CB(__skb) ((struct ah_skb_cb *)&((__skb)->cb[0])) 20 21 static void *ah_alloc_tmp(struct crypto_ahash *ahash, int nfrags, 22 unsigned int size) 23 { 24 unsigned int len; 25 26 len = size + crypto_ahash_digestsize(ahash) + 27 (crypto_ahash_alignmask(ahash) & 28 ~(crypto_tfm_ctx_alignment() - 1)); 29 30 len = ALIGN(len, crypto_tfm_ctx_alignment()); 31 32 len += sizeof(struct ahash_request) + crypto_ahash_reqsize(ahash); 33 len = ALIGN(len, __alignof__(struct scatterlist)); 34 35 len += sizeof(struct scatterlist) * nfrags; 36 37 return kmalloc(len, GFP_ATOMIC); 38 } 39 40 static inline u8 *ah_tmp_auth(void *tmp, unsigned int offset) 41 { 42 return tmp + offset; 43 } 44 45 static inline u8 *ah_tmp_icv(struct crypto_ahash *ahash, void *tmp, 46 unsigned int offset) 47 { 48 return PTR_ALIGN((u8 *)tmp + offset, crypto_ahash_alignmask(ahash) + 1); 49 } 50 51 static inline struct ahash_request *ah_tmp_req(struct crypto_ahash *ahash, 52 u8 *icv) 53 { 54 struct ahash_request *req; 55 56 req = (void *)PTR_ALIGN(icv + crypto_ahash_digestsize(ahash), 57 crypto_tfm_ctx_alignment()); 58 59 ahash_request_set_tfm(req, ahash); 60 61 return req; 62 } 63 64 static inline struct scatterlist *ah_req_sg(struct crypto_ahash *ahash, 65 struct ahash_request *req) 66 { 67 return (void *)ALIGN((unsigned long)(req + 1) + 68 crypto_ahash_reqsize(ahash), 69 __alignof__(struct scatterlist)); 70 } 71 72 /* Clear mutable options and find final destination to substitute 73 * into IP header for icv calculation. Options are already checked 74 * for validity, so paranoia is not required. */ 75 76 static int ip_clear_mutable_options(const struct iphdr *iph, __be32 *daddr) 77 { 78 unsigned char * optptr = (unsigned char*)(iph+1); 79 int l = iph->ihl*4 - sizeof(struct iphdr); 80 int optlen; 81 82 while (l > 0) { 83 switch (*optptr) { 84 case IPOPT_END: 85 return 0; 86 case IPOPT_NOOP: 87 l--; 88 optptr++; 89 continue; 90 } 91 optlen = optptr[1]; 92 if (optlen<2 || optlen>l) 93 return -EINVAL; 94 switch (*optptr) { 95 case IPOPT_SEC: 96 case 0x85: /* Some "Extended Security" crap. */ 97 case IPOPT_CIPSO: 98 case IPOPT_RA: 99 case 0x80|21: /* RFC1770 */ 100 break; 101 case IPOPT_LSRR: 102 case IPOPT_SSRR: 103 if (optlen < 6) 104 return -EINVAL; 105 memcpy(daddr, optptr+optlen-4, 4); 106 /* Fall through */ 107 default: 108 memset(optptr, 0, optlen); 109 } 110 l -= optlen; 111 optptr += optlen; 112 } 113 return 0; 114 } 115 116 static void ah_output_done(struct crypto_async_request *base, int err) 117 { 118 u8 *icv; 119 struct iphdr *iph; 120 struct sk_buff *skb = base->data; 121 struct xfrm_state *x = skb_dst(skb)->xfrm; 122 struct ah_data *ahp = x->data; 123 struct iphdr *top_iph = ip_hdr(skb); 124 struct ip_auth_hdr *ah = ip_auth_hdr(skb); 125 int ihl = ip_hdrlen(skb); 126 127 iph = AH_SKB_CB(skb)->tmp; 128 icv = ah_tmp_icv(ahp->ahash, iph, ihl); 129 memcpy(ah->auth_data, icv, ahp->icv_trunc_len); 130 131 top_iph->tos = iph->tos; 132 top_iph->ttl = iph->ttl; 133 top_iph->frag_off = iph->frag_off; 134 if (top_iph->ihl != 5) { 135 top_iph->daddr = iph->daddr; 136 memcpy(top_iph+1, iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); 137 } 138 139 kfree(AH_SKB_CB(skb)->tmp); 140 xfrm_output_resume(skb, err); 141 } 142 143 static int ah_output(struct xfrm_state *x, struct sk_buff *skb) 144 { 145 int err; 146 int nfrags; 147 int ihl; 148 u8 *icv; 149 struct sk_buff *trailer; 150 struct crypto_ahash *ahash; 151 struct ahash_request *req; 152 struct scatterlist *sg; 153 struct iphdr *iph, *top_iph; 154 struct ip_auth_hdr *ah; 155 struct ah_data *ahp; 156 157 ahp = x->data; 158 ahash = ahp->ahash; 159 160 if ((err = skb_cow_data(skb, 0, &trailer)) < 0) 161 goto out; 162 nfrags = err; 163 164 skb_push(skb, -skb_network_offset(skb)); 165 ah = ip_auth_hdr(skb); 166 ihl = ip_hdrlen(skb); 167 168 err = -ENOMEM; 169 iph = ah_alloc_tmp(ahash, nfrags, ihl); 170 if (!iph) 171 goto out; 172 173 icv = ah_tmp_icv(ahash, iph, ihl); 174 req = ah_tmp_req(ahash, icv); 175 sg = ah_req_sg(ahash, req); 176 177 memset(ah->auth_data, 0, ahp->icv_trunc_len); 178 179 top_iph = ip_hdr(skb); 180 181 iph->tos = top_iph->tos; 182 iph->ttl = top_iph->ttl; 183 iph->frag_off = top_iph->frag_off; 184 185 if (top_iph->ihl != 5) { 186 iph->daddr = top_iph->daddr; 187 memcpy(iph+1, top_iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); 188 err = ip_clear_mutable_options(top_iph, &top_iph->daddr); 189 if (err) 190 goto out_free; 191 } 192 193 ah->nexthdr = *skb_mac_header(skb); 194 *skb_mac_header(skb) = IPPROTO_AH; 195 196 top_iph->tos = 0; 197 top_iph->tot_len = htons(skb->len); 198 top_iph->frag_off = 0; 199 top_iph->ttl = 0; 200 top_iph->check = 0; 201 202 if (x->props.flags & XFRM_STATE_ALIGN4) 203 ah->hdrlen = (XFRM_ALIGN4(sizeof(*ah) + ahp->icv_trunc_len) >> 2) - 2; 204 else 205 ah->hdrlen = (XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len) >> 2) - 2; 206 207 ah->reserved = 0; 208 ah->spi = x->id.spi; 209 ah->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low); 210 211 sg_init_table(sg, nfrags); 212 skb_to_sgvec(skb, sg, 0, skb->len); 213 214 ahash_request_set_crypt(req, sg, icv, skb->len); 215 ahash_request_set_callback(req, 0, ah_output_done, skb); 216 217 AH_SKB_CB(skb)->tmp = iph; 218 219 err = crypto_ahash_digest(req); 220 if (err) { 221 if (err == -EINPROGRESS) 222 goto out; 223 224 if (err == -EBUSY) 225 err = NET_XMIT_DROP; 226 goto out_free; 227 } 228 229 memcpy(ah->auth_data, icv, ahp->icv_trunc_len); 230 231 top_iph->tos = iph->tos; 232 top_iph->ttl = iph->ttl; 233 top_iph->frag_off = iph->frag_off; 234 if (top_iph->ihl != 5) { 235 top_iph->daddr = iph->daddr; 236 memcpy(top_iph+1, iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); 237 } 238 239 out_free: 240 kfree(iph); 241 out: 242 return err; 243 } 244 245 static void ah_input_done(struct crypto_async_request *base, int err) 246 { 247 u8 *auth_data; 248 u8 *icv; 249 struct iphdr *work_iph; 250 struct sk_buff *skb = base->data; 251 struct xfrm_state *x = xfrm_input_state(skb); 252 struct ah_data *ahp = x->data; 253 struct ip_auth_hdr *ah = ip_auth_hdr(skb); 254 int ihl = ip_hdrlen(skb); 255 int ah_hlen = (ah->hdrlen + 2) << 2; 256 257 work_iph = AH_SKB_CB(skb)->tmp; 258 auth_data = ah_tmp_auth(work_iph, ihl); 259 icv = ah_tmp_icv(ahp->ahash, auth_data, ahp->icv_trunc_len); 260 261 err = memcmp(icv, auth_data, ahp->icv_trunc_len) ? -EBADMSG: 0; 262 if (err) 263 goto out; 264 265 err = ah->nexthdr; 266 267 skb->network_header += ah_hlen; 268 memcpy(skb_network_header(skb), work_iph, ihl); 269 __skb_pull(skb, ah_hlen + ihl); 270 skb_set_transport_header(skb, -ihl); 271 out: 272 kfree(AH_SKB_CB(skb)->tmp); 273 xfrm_input_resume(skb, err); 274 } 275 276 static int ah_input(struct xfrm_state *x, struct sk_buff *skb) 277 { 278 int ah_hlen; 279 int ihl; 280 int nexthdr; 281 int nfrags; 282 u8 *auth_data; 283 u8 *icv; 284 struct sk_buff *trailer; 285 struct crypto_ahash *ahash; 286 struct ahash_request *req; 287 struct scatterlist *sg; 288 struct iphdr *iph, *work_iph; 289 struct ip_auth_hdr *ah; 290 struct ah_data *ahp; 291 int err = -ENOMEM; 292 293 if (!pskb_may_pull(skb, sizeof(*ah))) 294 goto out; 295 296 ah = (struct ip_auth_hdr *)skb->data; 297 ahp = x->data; 298 ahash = ahp->ahash; 299 300 nexthdr = ah->nexthdr; 301 ah_hlen = (ah->hdrlen + 2) << 2; 302 303 if (x->props.flags & XFRM_STATE_ALIGN4) { 304 if (ah_hlen != XFRM_ALIGN4(sizeof(*ah) + ahp->icv_full_len) && 305 ah_hlen != XFRM_ALIGN4(sizeof(*ah) + ahp->icv_trunc_len)) 306 goto out; 307 } else { 308 if (ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_full_len) && 309 ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len)) 310 goto out; 311 } 312 313 if (!pskb_may_pull(skb, ah_hlen)) 314 goto out; 315 316 /* We are going to _remove_ AH header to keep sockets happy, 317 * so... Later this can change. */ 318 if (skb_cloned(skb) && 319 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) 320 goto out; 321 322 skb->ip_summed = CHECKSUM_NONE; 323 324 325 if ((err = skb_cow_data(skb, 0, &trailer)) < 0) 326 goto out; 327 nfrags = err; 328 329 ah = (struct ip_auth_hdr *)skb->data; 330 iph = ip_hdr(skb); 331 ihl = ip_hdrlen(skb); 332 333 work_iph = ah_alloc_tmp(ahash, nfrags, ihl + ahp->icv_trunc_len); 334 if (!work_iph) 335 goto out; 336 337 auth_data = ah_tmp_auth(work_iph, ihl); 338 icv = ah_tmp_icv(ahash, auth_data, ahp->icv_trunc_len); 339 req = ah_tmp_req(ahash, icv); 340 sg = ah_req_sg(ahash, req); 341 342 memcpy(work_iph, iph, ihl); 343 memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len); 344 memset(ah->auth_data, 0, ahp->icv_trunc_len); 345 346 iph->ttl = 0; 347 iph->tos = 0; 348 iph->frag_off = 0; 349 iph->check = 0; 350 if (ihl > sizeof(*iph)) { 351 __be32 dummy; 352 err = ip_clear_mutable_options(iph, &dummy); 353 if (err) 354 goto out_free; 355 } 356 357 skb_push(skb, ihl); 358 359 sg_init_table(sg, nfrags); 360 skb_to_sgvec(skb, sg, 0, skb->len); 361 362 ahash_request_set_crypt(req, sg, icv, skb->len); 363 ahash_request_set_callback(req, 0, ah_input_done, skb); 364 365 AH_SKB_CB(skb)->tmp = work_iph; 366 367 err = crypto_ahash_digest(req); 368 if (err) { 369 if (err == -EINPROGRESS) 370 goto out; 371 372 goto out_free; 373 } 374 375 err = memcmp(icv, auth_data, ahp->icv_trunc_len) ? -EBADMSG: 0; 376 if (err) 377 goto out_free; 378 379 skb->network_header += ah_hlen; 380 memcpy(skb_network_header(skb), work_iph, ihl); 381 __skb_pull(skb, ah_hlen + ihl); 382 skb_set_transport_header(skb, -ihl); 383 384 err = nexthdr; 385 386 out_free: 387 kfree (work_iph); 388 out: 389 return err; 390 } 391 392 static void ah4_err(struct sk_buff *skb, u32 info) 393 { 394 struct net *net = dev_net(skb->dev); 395 const struct iphdr *iph = (const struct iphdr *)skb->data; 396 struct ip_auth_hdr *ah = (struct ip_auth_hdr *)(skb->data+(iph->ihl<<2)); 397 struct xfrm_state *x; 398 399 if (icmp_hdr(skb)->type != ICMP_DEST_UNREACH || 400 icmp_hdr(skb)->code != ICMP_FRAG_NEEDED) 401 return; 402 403 x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr, 404 ah->spi, IPPROTO_AH, AF_INET); 405 if (!x) 406 return; 407 printk(KERN_DEBUG "pmtu discovery on SA AH/%08x/%08x\n", 408 ntohl(ah->spi), ntohl(iph->daddr)); 409 xfrm_state_put(x); 410 } 411 412 static int ah_init_state(struct xfrm_state *x) 413 { 414 struct ah_data *ahp = NULL; 415 struct xfrm_algo_desc *aalg_desc; 416 struct crypto_ahash *ahash; 417 418 if (!x->aalg) 419 goto error; 420 421 if (x->encap) 422 goto error; 423 424 ahp = kzalloc(sizeof(*ahp), GFP_KERNEL); 425 if (!ahp) 426 return -ENOMEM; 427 428 ahash = crypto_alloc_ahash(x->aalg->alg_name, 0, 0); 429 if (IS_ERR(ahash)) 430 goto error; 431 432 ahp->ahash = ahash; 433 if (crypto_ahash_setkey(ahash, x->aalg->alg_key, 434 (x->aalg->alg_key_len + 7) / 8)) 435 goto error; 436 437 /* 438 * Lookup the algorithm description maintained by xfrm_algo, 439 * verify crypto transform properties, and store information 440 * we need for AH processing. This lookup cannot fail here 441 * after a successful crypto_alloc_ahash(). 442 */ 443 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); 444 BUG_ON(!aalg_desc); 445 446 if (aalg_desc->uinfo.auth.icv_fullbits/8 != 447 crypto_ahash_digestsize(ahash)) { 448 printk(KERN_INFO "AH: %s digestsize %u != %hu\n", 449 x->aalg->alg_name, crypto_ahash_digestsize(ahash), 450 aalg_desc->uinfo.auth.icv_fullbits/8); 451 goto error; 452 } 453 454 ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8; 455 ahp->icv_trunc_len = x->aalg->alg_trunc_len/8; 456 457 BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN); 458 459 if (x->props.flags & XFRM_STATE_ALIGN4) 460 x->props.header_len = XFRM_ALIGN4(sizeof(struct ip_auth_hdr) + 461 ahp->icv_trunc_len); 462 else 463 x->props.header_len = XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + 464 ahp->icv_trunc_len); 465 if (x->props.mode == XFRM_MODE_TUNNEL) 466 x->props.header_len += sizeof(struct iphdr); 467 x->data = ahp; 468 469 return 0; 470 471 error: 472 if (ahp) { 473 crypto_free_ahash(ahp->ahash); 474 kfree(ahp); 475 } 476 return -EINVAL; 477 } 478 479 static void ah_destroy(struct xfrm_state *x) 480 { 481 struct ah_data *ahp = x->data; 482 483 if (!ahp) 484 return; 485 486 crypto_free_ahash(ahp->ahash); 487 kfree(ahp); 488 } 489 490 491 static const struct xfrm_type ah_type = 492 { 493 .description = "AH4", 494 .owner = THIS_MODULE, 495 .proto = IPPROTO_AH, 496 .flags = XFRM_TYPE_REPLAY_PROT, 497 .init_state = ah_init_state, 498 .destructor = ah_destroy, 499 .input = ah_input, 500 .output = ah_output 501 }; 502 503 static const struct net_protocol ah4_protocol = { 504 .handler = xfrm4_rcv, 505 .err_handler = ah4_err, 506 .no_policy = 1, 507 .netns_ok = 1, 508 }; 509 510 static int __init ah4_init(void) 511 { 512 if (xfrm_register_type(&ah_type, AF_INET) < 0) { 513 printk(KERN_INFO "ip ah init: can't add xfrm type\n"); 514 return -EAGAIN; 515 } 516 if (inet_add_protocol(&ah4_protocol, IPPROTO_AH) < 0) { 517 printk(KERN_INFO "ip ah init: can't add protocol\n"); 518 xfrm_unregister_type(&ah_type, AF_INET); 519 return -EAGAIN; 520 } 521 return 0; 522 } 523 524 static void __exit ah4_fini(void) 525 { 526 if (inet_del_protocol(&ah4_protocol, IPPROTO_AH) < 0) 527 printk(KERN_INFO "ip ah close: can't remove protocol\n"); 528 if (xfrm_unregister_type(&ah_type, AF_INET) < 0) 529 printk(KERN_INFO "ip ah close: can't remove xfrm type\n"); 530 } 531 532 module_init(ah4_init); 533 module_exit(ah4_fini); 534 MODULE_LICENSE("GPL"); 535 MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH); 536