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/ah.c.
27 #define pr_fmt(fmt) "IPv6: " fmt
29 #include <crypto/hash.h>
30 #include <linux/module.h>
31 #include <linux/slab.h>
34 #include <linux/crypto.h>
35 #include <linux/pfkeyv2.h>
36 #include <linux/string.h>
37 #include <linux/scatterlist.h>
38 #include <net/ip6_route.h>
41 #include <net/protocol.h>
44 #define IPV6HDR_BASELEN 8
47 #if IS_ENABLED(CONFIG_IPV6_MIP6)
48 struct in6_addr saddr
;
50 struct in6_addr daddr
;
55 struct xfrm_skb_cb xfrm
;
59 #define AH_SKB_CB(__skb) ((struct ah_skb_cb *)&((__skb)->cb[0]))
61 static void *ah_alloc_tmp(struct crypto_ahash
*ahash
, int nfrags
,
66 len
= size
+ crypto_ahash_digestsize(ahash
) +
67 (crypto_ahash_alignmask(ahash
) &
68 ~(crypto_tfm_ctx_alignment() - 1));
70 len
= ALIGN(len
, crypto_tfm_ctx_alignment());
72 len
+= sizeof(struct ahash_request
) + crypto_ahash_reqsize(ahash
);
73 len
= ALIGN(len
, __alignof__(struct scatterlist
));
75 len
+= sizeof(struct scatterlist
) * nfrags
;
77 return kmalloc(len
, GFP_ATOMIC
);
80 static inline struct tmp_ext
*ah_tmp_ext(void *base
)
82 return base
+ IPV6HDR_BASELEN
;
85 static inline u8
*ah_tmp_auth(u8
*tmp
, unsigned int offset
)
90 static inline u8
*ah_tmp_icv(struct crypto_ahash
*ahash
, void *tmp
,
93 return PTR_ALIGN((u8
*)tmp
+ offset
, crypto_ahash_alignmask(ahash
) + 1);
96 static inline struct ahash_request
*ah_tmp_req(struct crypto_ahash
*ahash
,
99 struct ahash_request
*req
;
101 req
= (void *)PTR_ALIGN(icv
+ crypto_ahash_digestsize(ahash
),
102 crypto_tfm_ctx_alignment());
104 ahash_request_set_tfm(req
, ahash
);
109 static inline struct scatterlist
*ah_req_sg(struct crypto_ahash
*ahash
,
110 struct ahash_request
*req
)
112 return (void *)ALIGN((unsigned long)(req
+ 1) +
113 crypto_ahash_reqsize(ahash
),
114 __alignof__(struct scatterlist
));
117 static bool zero_out_mutable_opts(struct ipv6_opt_hdr
*opthdr
)
119 u8
*opt
= (u8
*)opthdr
;
120 int len
= ipv6_optlen(opthdr
);
137 optlen
= opt
[off
+1]+2;
141 memset(&opt
[off
+2], 0, opt
[off
+1]);
155 #if IS_ENABLED(CONFIG_IPV6_MIP6)
157 * ipv6_rearrange_destopt - rearrange IPv6 destination options header
159 * @destopt: destionation options header
161 static void ipv6_rearrange_destopt(struct ipv6hdr
*iph
, struct ipv6_opt_hdr
*destopt
)
163 u8
*opt
= (u8
*)destopt
;
164 int len
= ipv6_optlen(destopt
);
181 optlen
= opt
[off
+1]+2;
185 /* Rearrange the source address in @iph and the
186 * addresses in home address option for final source.
187 * See 11.3.2 of RFC 3775 for details.
189 if (opt
[off
] == IPV6_TLV_HAO
) {
190 struct in6_addr final_addr
;
191 struct ipv6_destopt_hao
*hao
;
193 hao
= (struct ipv6_destopt_hao
*)&opt
[off
];
194 if (hao
->length
!= sizeof(hao
->addr
)) {
195 net_warn_ratelimited("destopt hao: invalid header length: %u\n",
199 final_addr
= hao
->addr
;
200 hao
->addr
= iph
->saddr
;
201 iph
->saddr
= final_addr
;
209 /* Note: ok if len == 0 */
214 static void ipv6_rearrange_destopt(struct ipv6hdr
*iph
, struct ipv6_opt_hdr
*destopt
) {}
218 * ipv6_rearrange_rthdr - rearrange IPv6 routing header
220 * @rthdr: routing header
222 * Rearrange the destination address in @iph and the addresses in @rthdr
223 * so that they appear in the order they will at the final destination.
224 * See Appendix A2 of RFC 2402 for details.
226 static void ipv6_rearrange_rthdr(struct ipv6hdr
*iph
, struct ipv6_rt_hdr
*rthdr
)
228 int segments
, segments_left
;
229 struct in6_addr
*addrs
;
230 struct in6_addr final_addr
;
232 segments_left
= rthdr
->segments_left
;
233 if (segments_left
== 0)
235 rthdr
->segments_left
= 0;
237 /* The value of rthdr->hdrlen has been verified either by the system
238 * call if it is locally generated, or by ipv6_rthdr_rcv() for incoming
239 * packets. So we can assume that it is even and that segments is
240 * greater than or equal to segments_left.
242 * For the same reason we can assume that this option is of type 0.
244 segments
= rthdr
->hdrlen
>> 1;
246 addrs
= ((struct rt0_hdr
*)rthdr
)->addr
;
247 final_addr
= addrs
[segments
- 1];
249 addrs
+= segments
- segments_left
;
250 memmove(addrs
+ 1, addrs
, (segments_left
- 1) * sizeof(*addrs
));
252 addrs
[0] = iph
->daddr
;
253 iph
->daddr
= final_addr
;
256 static int ipv6_clear_mutable_options(struct ipv6hdr
*iph
, int len
, int dir
)
260 struct ipv6_opt_hdr
*opth
;
261 struct ipv6_rt_hdr
*rth
;
263 } exthdr
= { .iph
= iph
};
264 char *end
= exthdr
.raw
+ len
;
265 int nexthdr
= iph
->nexthdr
;
269 while (exthdr
.raw
< end
) {
272 if (dir
== XFRM_POLICY_OUT
)
273 ipv6_rearrange_destopt(iph
, exthdr
.opth
);
275 if (!zero_out_mutable_opts(exthdr
.opth
)) {
277 KERN_WARNING
"overrun %sopts\n",
278 nexthdr
== NEXTHDR_HOP
?
284 case NEXTHDR_ROUTING
:
285 ipv6_rearrange_rthdr(iph
, exthdr
.rth
);
292 nexthdr
= exthdr
.opth
->nexthdr
;
293 exthdr
.raw
+= ipv6_optlen(exthdr
.opth
);
299 static void ah6_output_done(struct crypto_async_request
*base
, int err
)
304 struct sk_buff
*skb
= base
->data
;
305 struct xfrm_state
*x
= skb_dst(skb
)->xfrm
;
306 struct ah_data
*ahp
= x
->data
;
307 struct ipv6hdr
*top_iph
= ipv6_hdr(skb
);
308 struct ip_auth_hdr
*ah
= ip_auth_hdr(skb
);
309 struct tmp_ext
*iph_ext
;
311 extlen
= skb_network_header_len(skb
) - sizeof(struct ipv6hdr
);
313 extlen
+= sizeof(*iph_ext
);
315 iph_base
= AH_SKB_CB(skb
)->tmp
;
316 iph_ext
= ah_tmp_ext(iph_base
);
317 icv
= ah_tmp_icv(ahp
->ahash
, iph_ext
, extlen
);
319 memcpy(ah
->auth_data
, icv
, ahp
->icv_trunc_len
);
320 memcpy(top_iph
, iph_base
, IPV6HDR_BASELEN
);
323 #if IS_ENABLED(CONFIG_IPV6_MIP6)
324 memcpy(&top_iph
->saddr
, iph_ext
, extlen
);
326 memcpy(&top_iph
->daddr
, iph_ext
, extlen
);
330 kfree(AH_SKB_CB(skb
)->tmp
);
331 xfrm_output_resume(skb
, err
);
334 static int ah6_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
342 struct sk_buff
*trailer
;
343 struct crypto_ahash
*ahash
;
344 struct ahash_request
*req
;
345 struct scatterlist
*sg
;
346 struct ipv6hdr
*top_iph
;
347 struct ip_auth_hdr
*ah
;
349 struct tmp_ext
*iph_ext
;
354 if ((err
= skb_cow_data(skb
, 0, &trailer
)) < 0)
358 skb_push(skb
, -skb_network_offset(skb
));
359 extlen
= skb_network_header_len(skb
) - sizeof(struct ipv6hdr
);
361 extlen
+= sizeof(*iph_ext
);
364 iph_base
= ah_alloc_tmp(ahash
, nfrags
, IPV6HDR_BASELEN
+ extlen
);
368 iph_ext
= ah_tmp_ext(iph_base
);
369 icv
= ah_tmp_icv(ahash
, iph_ext
, extlen
);
370 req
= ah_tmp_req(ahash
, icv
);
371 sg
= ah_req_sg(ahash
, req
);
373 ah
= ip_auth_hdr(skb
);
374 memset(ah
->auth_data
, 0, ahp
->icv_trunc_len
);
376 top_iph
= ipv6_hdr(skb
);
377 top_iph
->payload_len
= htons(skb
->len
- sizeof(*top_iph
));
379 nexthdr
= *skb_mac_header(skb
);
380 *skb_mac_header(skb
) = IPPROTO_AH
;
382 /* When there are no extension headers, we only need to save the first
383 * 8 bytes of the base IP header.
385 memcpy(iph_base
, top_iph
, IPV6HDR_BASELEN
);
388 #if IS_ENABLED(CONFIG_IPV6_MIP6)
389 memcpy(iph_ext
, &top_iph
->saddr
, extlen
);
391 memcpy(iph_ext
, &top_iph
->daddr
, extlen
);
393 err
= ipv6_clear_mutable_options(top_iph
,
394 extlen
- sizeof(*iph_ext
) +
401 ah
->nexthdr
= nexthdr
;
403 top_iph
->priority
= 0;
404 top_iph
->flow_lbl
[0] = 0;
405 top_iph
->flow_lbl
[1] = 0;
406 top_iph
->flow_lbl
[2] = 0;
407 top_iph
->hop_limit
= 0;
409 ah
->hdrlen
= (XFRM_ALIGN8(sizeof(*ah
) + ahp
->icv_trunc_len
) >> 2) - 2;
413 ah
->seq_no
= htonl(XFRM_SKB_CB(skb
)->seq
.output
.low
);
415 sg_init_table(sg
, nfrags
);
416 skb_to_sgvec(skb
, sg
, 0, skb
->len
);
418 ahash_request_set_crypt(req
, sg
, icv
, skb
->len
);
419 ahash_request_set_callback(req
, 0, ah6_output_done
, skb
);
421 AH_SKB_CB(skb
)->tmp
= iph_base
;
423 err
= crypto_ahash_digest(req
);
425 if (err
== -EINPROGRESS
)
433 memcpy(ah
->auth_data
, icv
, ahp
->icv_trunc_len
);
434 memcpy(top_iph
, iph_base
, IPV6HDR_BASELEN
);
437 #if IS_ENABLED(CONFIG_IPV6_MIP6)
438 memcpy(&top_iph
->saddr
, iph_ext
, extlen
);
440 memcpy(&top_iph
->daddr
, iph_ext
, extlen
);
450 static void ah6_input_done(struct crypto_async_request
*base
, int err
)
455 struct sk_buff
*skb
= base
->data
;
456 struct xfrm_state
*x
= xfrm_input_state(skb
);
457 struct ah_data
*ahp
= x
->data
;
458 struct ip_auth_hdr
*ah
= ip_auth_hdr(skb
);
459 int hdr_len
= skb_network_header_len(skb
);
460 int ah_hlen
= (ah
->hdrlen
+ 2) << 2;
462 work_iph
= AH_SKB_CB(skb
)->tmp
;
463 auth_data
= ah_tmp_auth(work_iph
, hdr_len
);
464 icv
= ah_tmp_icv(ahp
->ahash
, auth_data
, ahp
->icv_trunc_len
);
466 err
= memcmp(icv
, auth_data
, ahp
->icv_trunc_len
) ? -EBADMSG
: 0;
472 skb
->network_header
+= ah_hlen
;
473 memcpy(skb_network_header(skb
), work_iph
, hdr_len
);
474 __skb_pull(skb
, ah_hlen
+ hdr_len
);
475 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
476 skb_reset_transport_header(skb
);
478 skb_set_transport_header(skb
, -hdr_len
);
480 kfree(AH_SKB_CB(skb
)->tmp
);
481 xfrm_input_resume(skb
, err
);
486 static int ah6_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
490 * [IPv6][Ext1][Ext2][AH][Dest][Payload]
491 * |<-------------->| hdr_len
494 * Keeping copy of cleared headers. After AH processing,
495 * Moving the pointer of skb->network_header by using skb_pull as long
496 * as AH header length. Then copy back the copy as long as hdr_len
497 * If destination header following AH exists, copy it into after [Ext2].
499 * |<>|[IPv6][Ext1][Ext2][Dest][Payload]
500 * There is offset of AH before IPv6 header after the process.
506 struct sk_buff
*trailer
;
507 struct crypto_ahash
*ahash
;
508 struct ahash_request
*req
;
509 struct scatterlist
*sg
;
510 struct ip_auth_hdr
*ah
;
511 struct ipv6hdr
*ip6h
;
519 if (!pskb_may_pull(skb
, sizeof(struct ip_auth_hdr
)))
522 /* We are going to _remove_ AH header to keep sockets happy,
523 * so... Later this can change. */
524 if (skb_cloned(skb
) &&
525 pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
))
528 skb
->ip_summed
= CHECKSUM_NONE
;
530 hdr_len
= skb_network_header_len(skb
);
531 ah
= (struct ip_auth_hdr
*)skb
->data
;
535 nexthdr
= ah
->nexthdr
;
536 ah_hlen
= (ah
->hdrlen
+ 2) << 2;
538 if (ah_hlen
!= XFRM_ALIGN8(sizeof(*ah
) + ahp
->icv_full_len
) &&
539 ah_hlen
!= XFRM_ALIGN8(sizeof(*ah
) + ahp
->icv_trunc_len
))
542 if (!pskb_may_pull(skb
, ah_hlen
))
546 if ((err
= skb_cow_data(skb
, 0, &trailer
)) < 0)
550 ah
= (struct ip_auth_hdr
*)skb
->data
;
551 ip6h
= ipv6_hdr(skb
);
553 skb_push(skb
, hdr_len
);
555 work_iph
= ah_alloc_tmp(ahash
, nfrags
, hdr_len
+ ahp
->icv_trunc_len
);
559 auth_data
= ah_tmp_auth(work_iph
, hdr_len
);
560 icv
= ah_tmp_icv(ahash
, auth_data
, ahp
->icv_trunc_len
);
561 req
= ah_tmp_req(ahash
, icv
);
562 sg
= ah_req_sg(ahash
, req
);
564 memcpy(work_iph
, ip6h
, hdr_len
);
565 memcpy(auth_data
, ah
->auth_data
, ahp
->icv_trunc_len
);
566 memset(ah
->auth_data
, 0, ahp
->icv_trunc_len
);
568 if (ipv6_clear_mutable_options(ip6h
, hdr_len
, XFRM_POLICY_IN
))
572 ip6h
->flow_lbl
[0] = 0;
573 ip6h
->flow_lbl
[1] = 0;
574 ip6h
->flow_lbl
[2] = 0;
577 sg_init_table(sg
, nfrags
);
578 skb_to_sgvec(skb
, sg
, 0, skb
->len
);
580 ahash_request_set_crypt(req
, sg
, icv
, skb
->len
);
581 ahash_request_set_callback(req
, 0, ah6_input_done
, skb
);
583 AH_SKB_CB(skb
)->tmp
= work_iph
;
585 err
= crypto_ahash_digest(req
);
587 if (err
== -EINPROGRESS
)
593 err
= memcmp(icv
, auth_data
, ahp
->icv_trunc_len
) ? -EBADMSG
: 0;
597 skb
->network_header
+= ah_hlen
;
598 memcpy(skb_network_header(skb
), work_iph
, hdr_len
);
599 __skb_pull(skb
, ah_hlen
+ hdr_len
);
601 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
602 skb_reset_transport_header(skb
);
604 skb_set_transport_header(skb
, -hdr_len
);
614 static void ah6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
615 u8 type
, u8 code
, int offset
, __be32 info
)
617 struct net
*net
= dev_net(skb
->dev
);
618 struct ipv6hdr
*iph
= (struct ipv6hdr
*)skb
->data
;
619 struct ip_auth_hdr
*ah
= (struct ip_auth_hdr
*)(skb
->data
+offset
);
620 struct xfrm_state
*x
;
622 if (type
!= ICMPV6_DEST_UNREACH
&&
623 type
!= ICMPV6_PKT_TOOBIG
&&
624 type
!= NDISC_REDIRECT
)
627 x
= xfrm_state_lookup(net
, skb
->mark
, (xfrm_address_t
*)&iph
->daddr
, ah
->spi
, IPPROTO_AH
, AF_INET6
);
631 if (type
== NDISC_REDIRECT
)
632 ip6_redirect(skb
, net
, 0, 0);
634 ip6_update_pmtu(skb
, net
, info
, 0, 0);
638 static int ah6_init_state(struct xfrm_state
*x
)
640 struct ah_data
*ahp
= NULL
;
641 struct xfrm_algo_desc
*aalg_desc
;
642 struct crypto_ahash
*ahash
;
650 ahp
= kzalloc(sizeof(*ahp
), GFP_KERNEL
);
654 ahash
= crypto_alloc_ahash(x
->aalg
->alg_name
, 0, 0);
659 if (crypto_ahash_setkey(ahash
, x
->aalg
->alg_key
,
660 (x
->aalg
->alg_key_len
+ 7) / 8))
664 * Lookup the algorithm description maintained by xfrm_algo,
665 * verify crypto transform properties, and store information
666 * we need for AH processing. This lookup cannot fail here
667 * after a successful crypto_alloc_hash().
669 aalg_desc
= xfrm_aalg_get_byname(x
->aalg
->alg_name
, 0);
672 if (aalg_desc
->uinfo
.auth
.icv_fullbits
/8 !=
673 crypto_ahash_digestsize(ahash
)) {
674 pr_info("AH: %s digestsize %u != %hu\n",
675 x
->aalg
->alg_name
, crypto_ahash_digestsize(ahash
),
676 aalg_desc
->uinfo
.auth
.icv_fullbits
/8);
680 ahp
->icv_full_len
= aalg_desc
->uinfo
.auth
.icv_fullbits
/8;
681 ahp
->icv_trunc_len
= x
->aalg
->alg_trunc_len
/8;
683 BUG_ON(ahp
->icv_trunc_len
> MAX_AH_AUTH_LEN
);
685 x
->props
.header_len
= XFRM_ALIGN8(sizeof(struct ip_auth_hdr
) +
687 switch (x
->props
.mode
) {
689 case XFRM_MODE_TRANSPORT
:
691 case XFRM_MODE_TUNNEL
:
692 x
->props
.header_len
+= sizeof(struct ipv6hdr
);
703 crypto_free_ahash(ahp
->ahash
);
709 static void ah6_destroy(struct xfrm_state
*x
)
711 struct ah_data
*ahp
= x
->data
;
716 crypto_free_ahash(ahp
->ahash
);
720 static const struct xfrm_type ah6_type
=
722 .description
= "AH6",
723 .owner
= THIS_MODULE
,
725 .flags
= XFRM_TYPE_REPLAY_PROT
,
726 .init_state
= ah6_init_state
,
727 .destructor
= ah6_destroy
,
729 .output
= ah6_output
,
730 .hdr_offset
= xfrm6_find_1stfragopt
,
733 static const struct inet6_protocol ah6_protocol
= {
734 .handler
= xfrm6_rcv
,
735 .err_handler
= ah6_err
,
736 .flags
= INET6_PROTO_NOPOLICY
,
739 static int __init
ah6_init(void)
741 if (xfrm_register_type(&ah6_type
, AF_INET6
) < 0) {
742 pr_info("%s: can't add xfrm type\n", __func__
);
746 if (inet6_add_protocol(&ah6_protocol
, IPPROTO_AH
) < 0) {
747 pr_info("%s: can't add protocol\n", __func__
);
748 xfrm_unregister_type(&ah6_type
, AF_INET6
);
755 static void __exit
ah6_fini(void)
757 if (inet6_del_protocol(&ah6_protocol
, IPPROTO_AH
) < 0)
758 pr_info("%s: can't remove protocol\n", __func__
);
760 if (xfrm_unregister_type(&ah6_type
, AF_INET6
) < 0)
761 pr_info("%s: can't remove xfrm type\n", __func__
);
765 module_init(ah6_init
);
766 module_exit(ah6_fini
);
768 MODULE_LICENSE("GPL");
769 MODULE_ALIAS_XFRM_TYPE(AF_INET6
, XFRM_PROTO_AH
);