1 // SPDX-License-Identifier: GPL-2.0-only
2 #define pr_fmt(fmt) "IPsec: " fmt
4 #include <crypto/aead.h>
5 #include <crypto/authenc.h>
7 #include <linux/module.h>
11 #include <linux/scatterlist.h>
12 #include <linux/kernel.h>
13 #include <linux/pfkeyv2.h>
14 #include <linux/rtnetlink.h>
15 #include <linux/slab.h>
16 #include <linux/spinlock.h>
17 #include <linux/in6.h>
19 #include <net/protocol.h>
22 #include <net/espintcp.h>
24 #include <linux/highmem.h>
27 struct xfrm_skb_cb xfrm
;
31 struct esp_output_extra
{
36 #define ESP_SKB_CB(__skb) ((struct esp_skb_cb *)&((__skb)->cb[0]))
39 * Allocate an AEAD request structure with extra space for SG and IV.
41 * For alignment considerations the IV is placed at the front, followed
42 * by the request and finally the SG list.
44 * TODO: Use spare space in skb for this where possible.
46 static void *esp_alloc_tmp(struct crypto_aead
*aead
, int nfrags
, int extralen
)
52 len
+= crypto_aead_ivsize(aead
);
55 len
+= crypto_aead_alignmask(aead
) &
56 ~(crypto_tfm_ctx_alignment() - 1);
57 len
= ALIGN(len
, crypto_tfm_ctx_alignment());
60 len
+= sizeof(struct aead_request
) + crypto_aead_reqsize(aead
);
61 len
= ALIGN(len
, __alignof__(struct scatterlist
));
63 len
+= sizeof(struct scatterlist
) * nfrags
;
65 return kmalloc(len
, GFP_ATOMIC
);
68 static inline void *esp_tmp_extra(void *tmp
)
70 return PTR_ALIGN(tmp
, __alignof__(struct esp_output_extra
));
73 static inline u8
*esp_tmp_iv(struct crypto_aead
*aead
, void *tmp
, int extralen
)
75 return crypto_aead_ivsize(aead
) ?
76 PTR_ALIGN((u8
*)tmp
+ extralen
,
77 crypto_aead_alignmask(aead
) + 1) : tmp
+ extralen
;
80 static inline struct aead_request
*esp_tmp_req(struct crypto_aead
*aead
, u8
*iv
)
82 struct aead_request
*req
;
84 req
= (void *)PTR_ALIGN(iv
+ crypto_aead_ivsize(aead
),
85 crypto_tfm_ctx_alignment());
86 aead_request_set_tfm(req
, aead
);
90 static inline struct scatterlist
*esp_req_sg(struct crypto_aead
*aead
,
91 struct aead_request
*req
)
93 return (void *)ALIGN((unsigned long)(req
+ 1) +
94 crypto_aead_reqsize(aead
),
95 __alignof__(struct scatterlist
));
98 static void esp_ssg_unref(struct xfrm_state
*x
, void *tmp
)
100 struct esp_output_extra
*extra
= esp_tmp_extra(tmp
);
101 struct crypto_aead
*aead
= x
->data
;
104 struct aead_request
*req
;
105 struct scatterlist
*sg
;
107 if (x
->props
.flags
& XFRM_STATE_ESN
)
108 extralen
+= sizeof(*extra
);
110 extra
= esp_tmp_extra(tmp
);
111 iv
= esp_tmp_iv(aead
, tmp
, extralen
);
112 req
= esp_tmp_req(aead
, iv
);
114 /* Unref skb_frag_pages in the src scatterlist if necessary.
115 * Skip the first sg which comes from skb->data.
117 if (req
->src
!= req
->dst
)
118 for (sg
= sg_next(req
->src
); sg
; sg
= sg_next(sg
))
119 put_page(sg_page(sg
));
122 #ifdef CONFIG_INET_ESPINTCP
128 static void esp_free_tcp_sk(struct rcu_head
*head
)
130 struct esp_tcp_sk
*esk
= container_of(head
, struct esp_tcp_sk
, rcu
);
136 static struct sock
*esp_find_tcp_sk(struct xfrm_state
*x
)
138 struct xfrm_encap_tmpl
*encap
= x
->encap
;
139 struct esp_tcp_sk
*esk
;
144 sk
= rcu_dereference(x
->encap_sk
);
145 if (sk
&& sk
->sk_state
== TCP_ESTABLISHED
)
148 spin_lock_bh(&x
->lock
);
149 sport
= encap
->encap_sport
;
150 dport
= encap
->encap_dport
;
151 nsk
= rcu_dereference_protected(x
->encap_sk
,
152 lockdep_is_held(&x
->lock
));
153 if (sk
&& sk
== nsk
) {
154 esk
= kmalloc(sizeof(*esk
), GFP_ATOMIC
);
156 spin_unlock_bh(&x
->lock
);
157 return ERR_PTR(-ENOMEM
);
159 RCU_INIT_POINTER(x
->encap_sk
, NULL
);
161 call_rcu(&esk
->rcu
, esp_free_tcp_sk
);
163 spin_unlock_bh(&x
->lock
);
165 sk
= inet_lookup_established(xs_net(x
), &tcp_hashinfo
, x
->id
.daddr
.a4
,
166 dport
, x
->props
.saddr
.a4
, sport
, 0);
168 return ERR_PTR(-ENOENT
);
170 if (!tcp_is_ulp_esp(sk
)) {
172 return ERR_PTR(-EINVAL
);
175 spin_lock_bh(&x
->lock
);
176 nsk
= rcu_dereference_protected(x
->encap_sk
,
177 lockdep_is_held(&x
->lock
));
178 if (encap
->encap_sport
!= sport
||
179 encap
->encap_dport
!= dport
) {
181 sk
= nsk
?: ERR_PTR(-EREMCHG
);
182 } else if (sk
== nsk
) {
185 rcu_assign_pointer(x
->encap_sk
, sk
);
187 spin_unlock_bh(&x
->lock
);
192 static int esp_output_tcp_finish(struct xfrm_state
*x
, struct sk_buff
*skb
)
199 sk
= esp_find_tcp_sk(x
);
200 err
= PTR_ERR_OR_ZERO(sk
);
205 if (sock_owned_by_user(sk
))
206 err
= espintcp_queue_out(sk
, skb
);
208 err
= espintcp_push_skb(sk
, skb
);
216 static int esp_output_tcp_encap_cb(struct net
*net
, struct sock
*sk
,
219 struct dst_entry
*dst
= skb_dst(skb
);
220 struct xfrm_state
*x
= dst
->xfrm
;
222 return esp_output_tcp_finish(x
, skb
);
225 static int esp_output_tail_tcp(struct xfrm_state
*x
, struct sk_buff
*skb
)
230 err
= xfrm_trans_queue_net(xs_net(x
), skb
, esp_output_tcp_encap_cb
);
233 /* EINPROGRESS just happens to do the right thing. It
234 * actually means that the skb has been consumed and
237 return err
?: -EINPROGRESS
;
240 static int esp_output_tail_tcp(struct xfrm_state
*x
, struct sk_buff
*skb
)
248 static void esp_output_done(struct crypto_async_request
*base
, int err
)
250 struct sk_buff
*skb
= base
->data
;
251 struct xfrm_offload
*xo
= xfrm_offload(skb
);
253 struct xfrm_state
*x
;
255 if (xo
&& (xo
->flags
& XFRM_DEV_RESUME
)) {
256 struct sec_path
*sp
= skb_sec_path(skb
);
258 x
= sp
->xvec
[sp
->len
- 1];
260 x
= skb_dst(skb
)->xfrm
;
263 tmp
= ESP_SKB_CB(skb
)->tmp
;
264 esp_ssg_unref(x
, tmp
);
267 if (xo
&& (xo
->flags
& XFRM_DEV_RESUME
)) {
269 XFRM_INC_STATS(xs_net(x
), LINUX_MIB_XFRMOUTSTATEPROTOERROR
);
274 skb_push(skb
, skb
->data
- skb_mac_header(skb
));
276 xfrm_dev_resume(skb
);
279 x
->encap
&& x
->encap
->encap_type
== TCP_ENCAP_ESPINTCP
)
280 esp_output_tail_tcp(x
, skb
);
282 xfrm_output_resume(skb
, err
);
286 /* Move ESP header back into place. */
287 static void esp_restore_header(struct sk_buff
*skb
, unsigned int offset
)
289 struct ip_esp_hdr
*esph
= (void *)(skb
->data
+ offset
);
290 void *tmp
= ESP_SKB_CB(skb
)->tmp
;
291 __be32
*seqhi
= esp_tmp_extra(tmp
);
293 esph
->seq_no
= esph
->spi
;
297 static void esp_output_restore_header(struct sk_buff
*skb
)
299 void *tmp
= ESP_SKB_CB(skb
)->tmp
;
300 struct esp_output_extra
*extra
= esp_tmp_extra(tmp
);
302 esp_restore_header(skb
, skb_transport_offset(skb
) + extra
->esphoff
-
306 static struct ip_esp_hdr
*esp_output_set_extra(struct sk_buff
*skb
,
307 struct xfrm_state
*x
,
308 struct ip_esp_hdr
*esph
,
309 struct esp_output_extra
*extra
)
311 /* For ESN we move the header forward by 4 bytes to
312 * accomodate the high bits. We will move it back after
315 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
317 struct xfrm_offload
*xo
= xfrm_offload(skb
);
322 seqhi
= XFRM_SKB_CB(skb
)->seq
.output
.hi
;
324 extra
->esphoff
= (unsigned char *)esph
-
325 skb_transport_header(skb
);
326 esph
= (struct ip_esp_hdr
*)((unsigned char *)esph
- 4);
327 extra
->seqhi
= esph
->spi
;
328 esph
->seq_no
= htonl(seqhi
);
331 esph
->spi
= x
->id
.spi
;
336 static void esp_output_done_esn(struct crypto_async_request
*base
, int err
)
338 struct sk_buff
*skb
= base
->data
;
340 esp_output_restore_header(skb
);
341 esp_output_done(base
, err
);
344 static struct ip_esp_hdr
*esp_output_udp_encap(struct sk_buff
*skb
,
346 struct esp_info
*esp
,
354 len
= skb
->len
+ esp
->tailen
- skb_transport_offset(skb
);
355 if (len
+ sizeof(struct iphdr
) > IP_MAX_MTU
)
356 return ERR_PTR(-EMSGSIZE
);
358 uh
= (struct udphdr
*)esp
->esph
;
361 uh
->len
= htons(len
);
364 *skb_mac_header(skb
) = IPPROTO_UDP
;
366 if (encap_type
== UDP_ENCAP_ESPINUDP_NON_IKE
) {
367 udpdata32
= (__be32
*)(uh
+ 1);
368 udpdata32
[0] = udpdata32
[1] = 0;
369 return (struct ip_esp_hdr
*)(udpdata32
+ 2);
372 return (struct ip_esp_hdr
*)(uh
+ 1);
375 #ifdef CONFIG_INET_ESPINTCP
376 static struct ip_esp_hdr
*esp_output_tcp_encap(struct xfrm_state
*x
,
378 struct esp_info
*esp
)
380 __be16
*lenp
= (void *)esp
->esph
;
381 struct ip_esp_hdr
*esph
;
385 len
= skb
->len
+ esp
->tailen
- skb_transport_offset(skb
);
386 if (len
> IP_MAX_MTU
)
387 return ERR_PTR(-EMSGSIZE
);
390 sk
= esp_find_tcp_sk(x
);
397 esph
= (struct ip_esp_hdr
*)(lenp
+ 1);
402 static struct ip_esp_hdr
*esp_output_tcp_encap(struct xfrm_state
*x
,
404 struct esp_info
*esp
)
406 return ERR_PTR(-EOPNOTSUPP
);
410 static int esp_output_encap(struct xfrm_state
*x
, struct sk_buff
*skb
,
411 struct esp_info
*esp
)
413 struct xfrm_encap_tmpl
*encap
= x
->encap
;
414 struct ip_esp_hdr
*esph
;
418 spin_lock_bh(&x
->lock
);
419 sport
= encap
->encap_sport
;
420 dport
= encap
->encap_dport
;
421 encap_type
= encap
->encap_type
;
422 spin_unlock_bh(&x
->lock
);
424 switch (encap_type
) {
426 case UDP_ENCAP_ESPINUDP
:
427 case UDP_ENCAP_ESPINUDP_NON_IKE
:
428 esph
= esp_output_udp_encap(skb
, encap_type
, esp
, sport
, dport
);
430 case TCP_ENCAP_ESPINTCP
:
431 esph
= esp_output_tcp_encap(x
, skb
, esp
);
436 return PTR_ERR(esph
);
443 int esp_output_head(struct xfrm_state
*x
, struct sk_buff
*skb
, struct esp_info
*esp
)
450 struct sk_buff
*trailer
;
451 int tailen
= esp
->tailen
;
453 /* this is non-NULL only with TCP/UDP Encapsulation */
455 int err
= esp_output_encap(x
, skb
, esp
);
461 if (!skb_cloned(skb
)) {
462 if (tailen
<= skb_tailroom(skb
)) {
465 tail
= skb_tail_pointer(trailer
);
468 } else if ((skb_shinfo(skb
)->nr_frags
< MAX_SKB_FRAGS
)
469 && !skb_has_frag_list(skb
)) {
471 struct sock
*sk
= skb
->sk
;
472 struct page_frag
*pfrag
= &x
->xfrag
;
474 esp
->inplace
= false;
476 allocsize
= ALIGN(tailen
, L1_CACHE_BYTES
);
478 spin_lock_bh(&x
->lock
);
480 if (unlikely(!skb_page_frag_refill(allocsize
, pfrag
, GFP_ATOMIC
))) {
481 spin_unlock_bh(&x
->lock
);
488 vaddr
= kmap_atomic(page
);
490 tail
= vaddr
+ pfrag
->offset
;
492 esp_output_fill_trailer(tail
, esp
->tfclen
, esp
->plen
, esp
->proto
);
494 kunmap_atomic(vaddr
);
496 nfrags
= skb_shinfo(skb
)->nr_frags
;
498 __skb_fill_page_desc(skb
, nfrags
, page
, pfrag
->offset
,
500 skb_shinfo(skb
)->nr_frags
= ++nfrags
;
502 pfrag
->offset
= pfrag
->offset
+ allocsize
;
504 spin_unlock_bh(&x
->lock
);
509 skb
->data_len
+= tailen
;
510 skb
->truesize
+= tailen
;
511 if (sk
&& sk_fullsock(sk
))
512 refcount_add(tailen
, &sk
->sk_wmem_alloc
);
519 esph_offset
= (unsigned char *)esp
->esph
- skb_transport_header(skb
);
521 nfrags
= skb_cow_data(skb
, tailen
, &trailer
);
524 tail
= skb_tail_pointer(trailer
);
525 esp
->esph
= (struct ip_esp_hdr
*)(skb_transport_header(skb
) + esph_offset
);
528 esp_output_fill_trailer(tail
, esp
->tfclen
, esp
->plen
, esp
->proto
);
529 pskb_put(skb
, trailer
, tailen
);
534 EXPORT_SYMBOL_GPL(esp_output_head
);
536 int esp_output_tail(struct xfrm_state
*x
, struct sk_buff
*skb
, struct esp_info
*esp
)
545 struct ip_esp_hdr
*esph
;
546 struct crypto_aead
*aead
;
547 struct aead_request
*req
;
548 struct scatterlist
*sg
, *dsg
;
549 struct esp_output_extra
*extra
;
552 assoclen
= sizeof(struct ip_esp_hdr
);
555 if (x
->props
.flags
& XFRM_STATE_ESN
) {
556 extralen
+= sizeof(*extra
);
557 assoclen
+= sizeof(__be32
);
561 alen
= crypto_aead_authsize(aead
);
562 ivlen
= crypto_aead_ivsize(aead
);
564 tmp
= esp_alloc_tmp(aead
, esp
->nfrags
+ 2, extralen
);
568 extra
= esp_tmp_extra(tmp
);
569 iv
= esp_tmp_iv(aead
, tmp
, extralen
);
570 req
= esp_tmp_req(aead
, iv
);
571 sg
= esp_req_sg(aead
, req
);
576 dsg
= &sg
[esp
->nfrags
];
578 esph
= esp_output_set_extra(skb
, x
, esp
->esph
, extra
);
581 sg_init_table(sg
, esp
->nfrags
);
582 err
= skb_to_sgvec(skb
, sg
,
583 (unsigned char *)esph
- skb
->data
,
584 assoclen
+ ivlen
+ esp
->clen
+ alen
);
585 if (unlikely(err
< 0))
590 struct page_frag
*pfrag
= &x
->xfrag
;
592 allocsize
= ALIGN(skb
->data_len
, L1_CACHE_BYTES
);
594 spin_lock_bh(&x
->lock
);
595 if (unlikely(!skb_page_frag_refill(allocsize
, pfrag
, GFP_ATOMIC
))) {
596 spin_unlock_bh(&x
->lock
);
600 skb_shinfo(skb
)->nr_frags
= 1;
604 /* replace page frags in skb with new page */
605 __skb_fill_page_desc(skb
, 0, page
, pfrag
->offset
, skb
->data_len
);
606 pfrag
->offset
= pfrag
->offset
+ allocsize
;
607 spin_unlock_bh(&x
->lock
);
609 sg_init_table(dsg
, skb_shinfo(skb
)->nr_frags
+ 1);
610 err
= skb_to_sgvec(skb
, dsg
,
611 (unsigned char *)esph
- skb
->data
,
612 assoclen
+ ivlen
+ esp
->clen
+ alen
);
613 if (unlikely(err
< 0))
617 if ((x
->props
.flags
& XFRM_STATE_ESN
))
618 aead_request_set_callback(req
, 0, esp_output_done_esn
, skb
);
620 aead_request_set_callback(req
, 0, esp_output_done
, skb
);
622 aead_request_set_crypt(req
, sg
, dsg
, ivlen
+ esp
->clen
, iv
);
623 aead_request_set_ad(req
, assoclen
);
625 memset(iv
, 0, ivlen
);
626 memcpy(iv
+ ivlen
- min(ivlen
, 8), (u8
*)&esp
->seqno
+ 8 - min(ivlen
, 8),
629 ESP_SKB_CB(skb
)->tmp
= tmp
;
630 err
= crypto_aead_encrypt(req
);
641 if ((x
->props
.flags
& XFRM_STATE_ESN
))
642 esp_output_restore_header(skb
);
646 esp_ssg_unref(x
, tmp
);
648 if (!err
&& x
->encap
&& x
->encap
->encap_type
== TCP_ENCAP_ESPINTCP
)
649 err
= esp_output_tail_tcp(x
, skb
);
656 EXPORT_SYMBOL_GPL(esp_output_tail
);
658 static int esp_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
662 struct ip_esp_hdr
*esph
;
663 struct crypto_aead
*aead
;
668 esp
.proto
= *skb_mac_header(skb
);
669 *skb_mac_header(skb
) = IPPROTO_ESP
;
671 /* skb is pure payload to encrypt */
674 alen
= crypto_aead_authsize(aead
);
678 struct xfrm_dst
*dst
= (struct xfrm_dst
*)skb_dst(skb
);
681 padto
= min(x
->tfcpad
, xfrm_state_mtu(x
, dst
->child_mtu_cached
));
682 if (skb
->len
< padto
)
683 esp
.tfclen
= padto
- skb
->len
;
685 blksize
= ALIGN(crypto_aead_blocksize(aead
), 4);
686 esp
.clen
= ALIGN(skb
->len
+ 2 + esp
.tfclen
, blksize
);
687 esp
.plen
= esp
.clen
- skb
->len
- esp
.tfclen
;
688 esp
.tailen
= esp
.tfclen
+ esp
.plen
+ alen
;
690 esp
.esph
= ip_esp_hdr(skb
);
692 esp
.nfrags
= esp_output_head(x
, skb
, &esp
);
697 esph
->spi
= x
->id
.spi
;
699 esph
->seq_no
= htonl(XFRM_SKB_CB(skb
)->seq
.output
.low
);
700 esp
.seqno
= cpu_to_be64(XFRM_SKB_CB(skb
)->seq
.output
.low
+
701 ((u64
)XFRM_SKB_CB(skb
)->seq
.output
.hi
<< 32));
703 skb_push(skb
, -skb_network_offset(skb
));
705 return esp_output_tail(x
, skb
, &esp
);
708 static inline int esp_remove_trailer(struct sk_buff
*skb
)
710 struct xfrm_state
*x
= xfrm_input_state(skb
);
711 struct xfrm_offload
*xo
= xfrm_offload(skb
);
712 struct crypto_aead
*aead
= x
->data
;
713 int alen
, hlen
, elen
;
719 alen
= crypto_aead_authsize(aead
);
720 hlen
= sizeof(struct ip_esp_hdr
) + crypto_aead_ivsize(aead
);
721 elen
= skb
->len
- hlen
;
723 if (xo
&& (xo
->flags
& XFRM_ESP_NO_TRAILER
)) {
728 if (skb_copy_bits(skb
, skb
->len
- alen
- 2, nexthdr
, 2))
733 if (padlen
+ 2 + alen
>= elen
) {
734 net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n",
735 padlen
+ 2, elen
- alen
);
739 trimlen
= alen
+ padlen
+ 2;
740 if (skb
->ip_summed
== CHECKSUM_COMPLETE
) {
741 csumdiff
= skb_checksum(skb
, skb
->len
- trimlen
, trimlen
, 0);
742 skb
->csum
= csum_block_sub(skb
->csum
, csumdiff
,
745 pskb_trim(skb
, skb
->len
- trimlen
);
753 int esp_input_done2(struct sk_buff
*skb
, int err
)
755 const struct iphdr
*iph
;
756 struct xfrm_state
*x
= xfrm_input_state(skb
);
757 struct xfrm_offload
*xo
= xfrm_offload(skb
);
758 struct crypto_aead
*aead
= x
->data
;
759 int hlen
= sizeof(struct ip_esp_hdr
) + crypto_aead_ivsize(aead
);
762 if (!xo
|| (xo
&& !(xo
->flags
& CRYPTO_DONE
)))
763 kfree(ESP_SKB_CB(skb
)->tmp
);
768 err
= esp_remove_trailer(skb
);
769 if (unlikely(err
< 0))
776 struct xfrm_encap_tmpl
*encap
= x
->encap
;
777 struct tcphdr
*th
= (void *)(skb_network_header(skb
) + ihl
);
778 struct udphdr
*uh
= (void *)(skb_network_header(skb
) + ihl
);
781 switch (x
->encap
->encap_type
) {
782 case TCP_ENCAP_ESPINTCP
:
785 case UDP_ENCAP_ESPINUDP
:
786 case UDP_ENCAP_ESPINUDP_NON_IKE
:
796 * 1) if the NAT-T peer's IP or port changed then
797 * advertize the change to the keying daemon.
798 * This is an inbound SA, so just compare
801 if (iph
->saddr
!= x
->props
.saddr
.a4
||
802 source
!= encap
->encap_sport
) {
803 xfrm_address_t ipaddr
;
805 ipaddr
.a4
= iph
->saddr
;
806 km_new_mapping(x
, &ipaddr
, source
);
808 /* XXX: perhaps add an extra
809 * policy check here, to see
810 * if we should allow or
811 * reject a packet from a
818 * 2) ignore UDP/TCP checksums in case
819 * of NAT-T in Transport Mode, or
820 * perform other post-processing fixes
821 * as per draft-ietf-ipsec-udp-encaps-06,
824 if (x
->props
.mode
== XFRM_MODE_TRANSPORT
)
825 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
828 skb_pull_rcsum(skb
, hlen
);
829 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
830 skb_reset_transport_header(skb
);
832 skb_set_transport_header(skb
, -ihl
);
834 /* RFC4303: Drop dummy packets without any error */
835 if (err
== IPPROTO_NONE
)
841 EXPORT_SYMBOL_GPL(esp_input_done2
);
843 static void esp_input_done(struct crypto_async_request
*base
, int err
)
845 struct sk_buff
*skb
= base
->data
;
847 xfrm_input_resume(skb
, esp_input_done2(skb
, err
));
850 static void esp_input_restore_header(struct sk_buff
*skb
)
852 esp_restore_header(skb
, 0);
856 static void esp_input_set_header(struct sk_buff
*skb
, __be32
*seqhi
)
858 struct xfrm_state
*x
= xfrm_input_state(skb
);
859 struct ip_esp_hdr
*esph
;
861 /* For ESN we move the header forward by 4 bytes to
862 * accomodate the high bits. We will move it back after
865 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
866 esph
= skb_push(skb
, 4);
868 esph
->spi
= esph
->seq_no
;
869 esph
->seq_no
= XFRM_SKB_CB(skb
)->seq
.input
.hi
;
873 static void esp_input_done_esn(struct crypto_async_request
*base
, int err
)
875 struct sk_buff
*skb
= base
->data
;
877 esp_input_restore_header(skb
);
878 esp_input_done(base
, err
);
882 * Note: detecting truncated vs. non-truncated authentication data is very
883 * expensive, so we only support truncated data, which is the recommended
886 static int esp_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
888 struct crypto_aead
*aead
= x
->data
;
889 struct aead_request
*req
;
890 struct sk_buff
*trailer
;
891 int ivlen
= crypto_aead_ivsize(aead
);
892 int elen
= skb
->len
- sizeof(struct ip_esp_hdr
) - ivlen
;
899 struct scatterlist
*sg
;
902 if (!pskb_may_pull(skb
, sizeof(struct ip_esp_hdr
) + ivlen
))
908 assoclen
= sizeof(struct ip_esp_hdr
);
911 if (x
->props
.flags
& XFRM_STATE_ESN
) {
912 seqhilen
+= sizeof(__be32
);
913 assoclen
+= seqhilen
;
916 if (!skb_cloned(skb
)) {
917 if (!skb_is_nonlinear(skb
)) {
921 } else if (!skb_has_frag_list(skb
)) {
922 nfrags
= skb_shinfo(skb
)->nr_frags
;
929 err
= skb_cow_data(skb
, 0, &trailer
);
937 tmp
= esp_alloc_tmp(aead
, nfrags
, seqhilen
);
941 ESP_SKB_CB(skb
)->tmp
= tmp
;
942 seqhi
= esp_tmp_extra(tmp
);
943 iv
= esp_tmp_iv(aead
, tmp
, seqhilen
);
944 req
= esp_tmp_req(aead
, iv
);
945 sg
= esp_req_sg(aead
, req
);
947 esp_input_set_header(skb
, seqhi
);
949 sg_init_table(sg
, nfrags
);
950 err
= skb_to_sgvec(skb
, sg
, 0, skb
->len
);
951 if (unlikely(err
< 0)) {
956 skb
->ip_summed
= CHECKSUM_NONE
;
958 if ((x
->props
.flags
& XFRM_STATE_ESN
))
959 aead_request_set_callback(req
, 0, esp_input_done_esn
, skb
);
961 aead_request_set_callback(req
, 0, esp_input_done
, skb
);
963 aead_request_set_crypt(req
, sg
, sg
, elen
+ ivlen
, iv
);
964 aead_request_set_ad(req
, assoclen
);
966 err
= crypto_aead_decrypt(req
);
967 if (err
== -EINPROGRESS
)
970 if ((x
->props
.flags
& XFRM_STATE_ESN
))
971 esp_input_restore_header(skb
);
973 err
= esp_input_done2(skb
, err
);
979 static int esp4_err(struct sk_buff
*skb
, u32 info
)
981 struct net
*net
= dev_net(skb
->dev
);
982 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
983 struct ip_esp_hdr
*esph
= (struct ip_esp_hdr
*)(skb
->data
+(iph
->ihl
<<2));
984 struct xfrm_state
*x
;
986 switch (icmp_hdr(skb
)->type
) {
987 case ICMP_DEST_UNREACH
:
988 if (icmp_hdr(skb
)->code
!= ICMP_FRAG_NEEDED
)
996 x
= xfrm_state_lookup(net
, skb
->mark
, (const xfrm_address_t
*)&iph
->daddr
,
997 esph
->spi
, IPPROTO_ESP
, AF_INET
);
1001 if (icmp_hdr(skb
)->type
== ICMP_DEST_UNREACH
)
1002 ipv4_update_pmtu(skb
, net
, info
, 0, IPPROTO_ESP
);
1004 ipv4_redirect(skb
, net
, 0, IPPROTO_ESP
);
1010 static void esp_destroy(struct xfrm_state
*x
)
1012 struct crypto_aead
*aead
= x
->data
;
1017 crypto_free_aead(aead
);
1020 static int esp_init_aead(struct xfrm_state
*x
)
1022 char aead_name
[CRYPTO_MAX_ALG_NAME
];
1023 struct crypto_aead
*aead
;
1026 err
= -ENAMETOOLONG
;
1027 if (snprintf(aead_name
, CRYPTO_MAX_ALG_NAME
, "%s(%s)",
1028 x
->geniv
, x
->aead
->alg_name
) >= CRYPTO_MAX_ALG_NAME
)
1031 aead
= crypto_alloc_aead(aead_name
, 0, 0);
1032 err
= PTR_ERR(aead
);
1038 err
= crypto_aead_setkey(aead
, x
->aead
->alg_key
,
1039 (x
->aead
->alg_key_len
+ 7) / 8);
1043 err
= crypto_aead_setauthsize(aead
, x
->aead
->alg_icv_len
/ 8);
1051 static int esp_init_authenc(struct xfrm_state
*x
)
1053 struct crypto_aead
*aead
;
1054 struct crypto_authenc_key_param
*param
;
1058 char authenc_name
[CRYPTO_MAX_ALG_NAME
];
1059 unsigned int keylen
;
1066 err
= -ENAMETOOLONG
;
1068 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
1069 if (snprintf(authenc_name
, CRYPTO_MAX_ALG_NAME
,
1070 "%s%sauthencesn(%s,%s)%s",
1071 x
->geniv
?: "", x
->geniv
? "(" : "",
1072 x
->aalg
? x
->aalg
->alg_name
: "digest_null",
1074 x
->geniv
? ")" : "") >= CRYPTO_MAX_ALG_NAME
)
1077 if (snprintf(authenc_name
, CRYPTO_MAX_ALG_NAME
,
1078 "%s%sauthenc(%s,%s)%s",
1079 x
->geniv
?: "", x
->geniv
? "(" : "",
1080 x
->aalg
? x
->aalg
->alg_name
: "digest_null",
1082 x
->geniv
? ")" : "") >= CRYPTO_MAX_ALG_NAME
)
1086 aead
= crypto_alloc_aead(authenc_name
, 0, 0);
1087 err
= PTR_ERR(aead
);
1093 keylen
= (x
->aalg
? (x
->aalg
->alg_key_len
+ 7) / 8 : 0) +
1094 (x
->ealg
->alg_key_len
+ 7) / 8 + RTA_SPACE(sizeof(*param
));
1096 key
= kmalloc(keylen
, GFP_KERNEL
);
1102 rta
->rta_type
= CRYPTO_AUTHENC_KEYA_PARAM
;
1103 rta
->rta_len
= RTA_LENGTH(sizeof(*param
));
1104 param
= RTA_DATA(rta
);
1105 p
+= RTA_SPACE(sizeof(*param
));
1108 struct xfrm_algo_desc
*aalg_desc
;
1110 memcpy(p
, x
->aalg
->alg_key
, (x
->aalg
->alg_key_len
+ 7) / 8);
1111 p
+= (x
->aalg
->alg_key_len
+ 7) / 8;
1113 aalg_desc
= xfrm_aalg_get_byname(x
->aalg
->alg_name
, 0);
1117 if (aalg_desc
->uinfo
.auth
.icv_fullbits
/ 8 !=
1118 crypto_aead_authsize(aead
)) {
1119 pr_info("ESP: %s digestsize %u != %hu\n",
1121 crypto_aead_authsize(aead
),
1122 aalg_desc
->uinfo
.auth
.icv_fullbits
/ 8);
1126 err
= crypto_aead_setauthsize(
1127 aead
, x
->aalg
->alg_trunc_len
/ 8);
1132 param
->enckeylen
= cpu_to_be32((x
->ealg
->alg_key_len
+ 7) / 8);
1133 memcpy(p
, x
->ealg
->alg_key
, (x
->ealg
->alg_key_len
+ 7) / 8);
1135 err
= crypto_aead_setkey(aead
, key
, keylen
);
1144 static int esp_init_state(struct xfrm_state
*x
)
1146 struct crypto_aead
*aead
;
1153 err
= esp_init_aead(x
);
1155 err
= esp_init_authenc(x
);
1162 x
->props
.header_len
= sizeof(struct ip_esp_hdr
) +
1163 crypto_aead_ivsize(aead
);
1164 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
1165 x
->props
.header_len
+= sizeof(struct iphdr
);
1166 else if (x
->props
.mode
== XFRM_MODE_BEET
&& x
->sel
.family
!= AF_INET6
)
1167 x
->props
.header_len
+= IPV4_BEET_PHMAXLEN
;
1169 struct xfrm_encap_tmpl
*encap
= x
->encap
;
1171 switch (encap
->encap_type
) {
1175 case UDP_ENCAP_ESPINUDP
:
1176 x
->props
.header_len
+= sizeof(struct udphdr
);
1178 case UDP_ENCAP_ESPINUDP_NON_IKE
:
1179 x
->props
.header_len
+= sizeof(struct udphdr
) + 2 * sizeof(u32
);
1181 #ifdef CONFIG_INET_ESPINTCP
1182 case TCP_ENCAP_ESPINTCP
:
1183 /* only the length field, TCP encap is done by
1186 x
->props
.header_len
+= 2;
1192 align
= ALIGN(crypto_aead_blocksize(aead
), 4);
1193 x
->props
.trailer_len
= align
+ 1 + crypto_aead_authsize(aead
);
1199 static int esp4_rcv_cb(struct sk_buff
*skb
, int err
)
1204 static const struct xfrm_type esp_type
=
1206 .description
= "ESP4",
1207 .owner
= THIS_MODULE
,
1208 .proto
= IPPROTO_ESP
,
1209 .flags
= XFRM_TYPE_REPLAY_PROT
,
1210 .init_state
= esp_init_state
,
1211 .destructor
= esp_destroy
,
1213 .output
= esp_output
,
1216 static struct xfrm4_protocol esp4_protocol
= {
1217 .handler
= xfrm4_rcv
,
1218 .input_handler
= xfrm_input
,
1219 .cb_handler
= esp4_rcv_cb
,
1220 .err_handler
= esp4_err
,
1224 static int __init
esp4_init(void)
1226 if (xfrm_register_type(&esp_type
, AF_INET
) < 0) {
1227 pr_info("%s: can't add xfrm type\n", __func__
);
1230 if (xfrm4_protocol_register(&esp4_protocol
, IPPROTO_ESP
) < 0) {
1231 pr_info("%s: can't add protocol\n", __func__
);
1232 xfrm_unregister_type(&esp_type
, AF_INET
);
1238 static void __exit
esp4_fini(void)
1240 if (xfrm4_protocol_deregister(&esp4_protocol
, IPPROTO_ESP
) < 0)
1241 pr_info("%s: can't remove protocol\n", __func__
);
1242 xfrm_unregister_type(&esp_type
, AF_INET
);
1245 module_init(esp4_init
);
1246 module_exit(esp4_fini
);
1247 MODULE_LICENSE("GPL");
1248 MODULE_ALIAS_XFRM_TYPE(AF_INET
, XFRM_PROTO_ESP
);