1 #define pr_fmt(fmt) "IPsec: " fmt
3 #include <crypto/aead.h>
4 #include <crypto/authenc.h>
6 #include <linux/module.h>
10 #include <linux/scatterlist.h>
11 #include <linux/kernel.h>
12 #include <linux/pfkeyv2.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/slab.h>
15 #include <linux/spinlock.h>
16 #include <linux/in6.h>
18 #include <net/protocol.h>
21 #include <linux/highmem.h>
24 struct xfrm_skb_cb xfrm
;
28 struct esp_output_extra
{
33 #define ESP_SKB_CB(__skb) ((struct esp_skb_cb *)&((__skb)->cb[0]))
35 static u32
esp4_get_mtu(struct xfrm_state
*x
, int mtu
);
38 * Allocate an AEAD request structure with extra space for SG and IV.
40 * For alignment considerations the IV is placed at the front, followed
41 * by the request and finally the SG list.
43 * TODO: Use spare space in skb for this where possible.
45 static void *esp_alloc_tmp(struct crypto_aead
*aead
, int nfrags
, int extralen
)
51 len
+= crypto_aead_ivsize(aead
);
54 len
+= crypto_aead_alignmask(aead
) &
55 ~(crypto_tfm_ctx_alignment() - 1);
56 len
= ALIGN(len
, crypto_tfm_ctx_alignment());
59 len
+= sizeof(struct aead_request
) + crypto_aead_reqsize(aead
);
60 len
= ALIGN(len
, __alignof__(struct scatterlist
));
62 len
+= sizeof(struct scatterlist
) * nfrags
;
64 return kmalloc(len
, GFP_ATOMIC
);
67 static inline void *esp_tmp_extra(void *tmp
)
69 return PTR_ALIGN(tmp
, __alignof__(struct esp_output_extra
));
72 static inline u8
*esp_tmp_iv(struct crypto_aead
*aead
, void *tmp
, int extralen
)
74 return crypto_aead_ivsize(aead
) ?
75 PTR_ALIGN((u8
*)tmp
+ extralen
,
76 crypto_aead_alignmask(aead
) + 1) : tmp
+ extralen
;
79 static inline struct aead_request
*esp_tmp_req(struct crypto_aead
*aead
, u8
*iv
)
81 struct aead_request
*req
;
83 req
= (void *)PTR_ALIGN(iv
+ crypto_aead_ivsize(aead
),
84 crypto_tfm_ctx_alignment());
85 aead_request_set_tfm(req
, aead
);
89 static inline struct scatterlist
*esp_req_sg(struct crypto_aead
*aead
,
90 struct aead_request
*req
)
92 return (void *)ALIGN((unsigned long)(req
+ 1) +
93 crypto_aead_reqsize(aead
),
94 __alignof__(struct scatterlist
));
97 static void esp_ssg_unref(struct xfrm_state
*x
, void *tmp
)
99 struct esp_output_extra
*extra
= esp_tmp_extra(tmp
);
100 struct crypto_aead
*aead
= x
->data
;
103 struct aead_request
*req
;
104 struct scatterlist
*sg
;
106 if (x
->props
.flags
& XFRM_STATE_ESN
)
107 extralen
+= sizeof(*extra
);
109 extra
= esp_tmp_extra(tmp
);
110 iv
= esp_tmp_iv(aead
, tmp
, extralen
);
111 req
= esp_tmp_req(aead
, iv
);
113 /* Unref skb_frag_pages in the src scatterlist if necessary.
114 * Skip the first sg which comes from skb->data.
116 if (req
->src
!= req
->dst
)
117 for (sg
= sg_next(req
->src
); sg
; sg
= sg_next(sg
))
118 put_page(sg_page(sg
));
121 static void esp_output_done(struct crypto_async_request
*base
, int err
)
123 struct sk_buff
*skb
= base
->data
;
125 struct dst_entry
*dst
= skb_dst(skb
);
126 struct xfrm_state
*x
= dst
->xfrm
;
128 tmp
= ESP_SKB_CB(skb
)->tmp
;
129 esp_ssg_unref(x
, tmp
);
131 xfrm_output_resume(skb
, err
);
134 /* Move ESP header back into place. */
135 static void esp_restore_header(struct sk_buff
*skb
, unsigned int offset
)
137 struct ip_esp_hdr
*esph
= (void *)(skb
->data
+ offset
);
138 void *tmp
= ESP_SKB_CB(skb
)->tmp
;
139 __be32
*seqhi
= esp_tmp_extra(tmp
);
141 esph
->seq_no
= esph
->spi
;
145 static void esp_output_restore_header(struct sk_buff
*skb
)
147 void *tmp
= ESP_SKB_CB(skb
)->tmp
;
148 struct esp_output_extra
*extra
= esp_tmp_extra(tmp
);
150 esp_restore_header(skb
, skb_transport_offset(skb
) + extra
->esphoff
-
154 static struct ip_esp_hdr
*esp_output_set_extra(struct sk_buff
*skb
,
155 struct xfrm_state
*x
,
156 struct ip_esp_hdr
*esph
,
157 struct esp_output_extra
*extra
)
159 /* For ESN we move the header forward by 4 bytes to
160 * accomodate the high bits. We will move it back after
163 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
165 struct xfrm_offload
*xo
= xfrm_offload(skb
);
170 seqhi
= XFRM_SKB_CB(skb
)->seq
.output
.hi
;
172 extra
->esphoff
= (unsigned char *)esph
-
173 skb_transport_header(skb
);
174 esph
= (struct ip_esp_hdr
*)((unsigned char *)esph
- 4);
175 extra
->seqhi
= esph
->spi
;
176 esph
->seq_no
= htonl(seqhi
);
179 esph
->spi
= x
->id
.spi
;
184 static void esp_output_done_esn(struct crypto_async_request
*base
, int err
)
186 struct sk_buff
*skb
= base
->data
;
188 esp_output_restore_header(skb
);
189 esp_output_done(base
, err
);
192 static void esp_output_fill_trailer(u8
*tail
, int tfclen
, int plen
, __u8 proto
)
194 /* Fill padding... */
196 memset(tail
, 0, tfclen
);
201 for (i
= 0; i
< plen
- 2; i
++)
204 tail
[plen
- 2] = plen
- 2;
205 tail
[plen
- 1] = proto
;
208 static void esp_output_udp_encap(struct xfrm_state
*x
, struct sk_buff
*skb
, struct esp_info
*esp
)
214 struct xfrm_encap_tmpl
*encap
= x
->encap
;
215 struct ip_esp_hdr
*esph
= esp
->esph
;
217 spin_lock_bh(&x
->lock
);
218 sport
= encap
->encap_sport
;
219 dport
= encap
->encap_dport
;
220 encap_type
= encap
->encap_type
;
221 spin_unlock_bh(&x
->lock
);
223 uh
= (struct udphdr
*)esph
;
226 uh
->len
= htons(skb
->len
+ esp
->tailen
227 - skb_transport_offset(skb
));
230 switch (encap_type
) {
232 case UDP_ENCAP_ESPINUDP
:
233 esph
= (struct ip_esp_hdr
*)(uh
+ 1);
235 case UDP_ENCAP_ESPINUDP_NON_IKE
:
236 udpdata32
= (__be32
*)(uh
+ 1);
237 udpdata32
[0] = udpdata32
[1] = 0;
238 esph
= (struct ip_esp_hdr
*)(udpdata32
+ 2);
242 *skb_mac_header(skb
) = IPPROTO_UDP
;
246 int esp_output_head(struct xfrm_state
*x
, struct sk_buff
*skb
, struct esp_info
*esp
)
253 struct sk_buff
*trailer
;
254 int tailen
= esp
->tailen
;
256 /* this is non-NULL only with UDP Encapsulation */
258 esp_output_udp_encap(x
, skb
, esp
);
260 if (!skb_cloned(skb
)) {
261 if (tailen
<= skb_availroom(skb
)) {
264 tail
= skb_tail_pointer(trailer
);
267 } else if ((skb_shinfo(skb
)->nr_frags
< MAX_SKB_FRAGS
)
268 && !skb_has_frag_list(skb
)) {
270 struct sock
*sk
= skb
->sk
;
271 struct page_frag
*pfrag
= &x
->xfrag
;
273 esp
->inplace
= false;
275 allocsize
= ALIGN(tailen
, L1_CACHE_BYTES
);
277 spin_lock_bh(&x
->lock
);
279 if (unlikely(!skb_page_frag_refill(allocsize
, pfrag
, GFP_ATOMIC
))) {
280 spin_unlock_bh(&x
->lock
);
287 vaddr
= kmap_atomic(page
);
289 tail
= vaddr
+ pfrag
->offset
;
291 esp_output_fill_trailer(tail
, esp
->tfclen
, esp
->plen
, esp
->proto
);
293 kunmap_atomic(vaddr
);
295 spin_unlock_bh(&x
->lock
);
297 nfrags
= skb_shinfo(skb
)->nr_frags
;
299 __skb_fill_page_desc(skb
, nfrags
, page
, pfrag
->offset
,
301 skb_shinfo(skb
)->nr_frags
= ++nfrags
;
303 pfrag
->offset
= pfrag
->offset
+ allocsize
;
307 skb
->data_len
+= tailen
;
308 skb
->truesize
+= tailen
;
310 atomic_add(tailen
, &sk
->sk_wmem_alloc
);
317 esph_offset
= (unsigned char *)esp
->esph
- skb_transport_header(skb
);
319 nfrags
= skb_cow_data(skb
, tailen
, &trailer
);
322 tail
= skb_tail_pointer(trailer
);
323 esp
->esph
= (struct ip_esp_hdr
*)(skb_transport_header(skb
) + esph_offset
);
326 esp_output_fill_trailer(tail
, esp
->tfclen
, esp
->plen
, esp
->proto
);
327 pskb_put(skb
, trailer
, tailen
);
332 EXPORT_SYMBOL_GPL(esp_output_head
);
334 int esp_output_tail(struct xfrm_state
*x
, struct sk_buff
*skb
, struct esp_info
*esp
)
343 struct ip_esp_hdr
*esph
;
344 struct crypto_aead
*aead
;
345 struct aead_request
*req
;
346 struct scatterlist
*sg
, *dsg
;
347 struct esp_output_extra
*extra
;
350 assoclen
= sizeof(struct ip_esp_hdr
);
353 if (x
->props
.flags
& XFRM_STATE_ESN
) {
354 extralen
+= sizeof(*extra
);
355 assoclen
+= sizeof(__be32
);
359 alen
= crypto_aead_authsize(aead
);
360 ivlen
= crypto_aead_ivsize(aead
);
362 tmp
= esp_alloc_tmp(aead
, esp
->nfrags
+ 2, extralen
);
366 extra
= esp_tmp_extra(tmp
);
367 iv
= esp_tmp_iv(aead
, tmp
, extralen
);
368 req
= esp_tmp_req(aead
, iv
);
369 sg
= esp_req_sg(aead
, req
);
374 dsg
= &sg
[esp
->nfrags
];
376 esph
= esp_output_set_extra(skb
, x
, esp
->esph
, extra
);
379 sg_init_table(sg
, esp
->nfrags
);
380 skb_to_sgvec(skb
, sg
,
381 (unsigned char *)esph
- skb
->data
,
382 assoclen
+ ivlen
+ esp
->clen
+ alen
);
386 struct page_frag
*pfrag
= &x
->xfrag
;
388 allocsize
= ALIGN(skb
->data_len
, L1_CACHE_BYTES
);
390 spin_lock_bh(&x
->lock
);
391 if (unlikely(!skb_page_frag_refill(allocsize
, pfrag
, GFP_ATOMIC
))) {
392 spin_unlock_bh(&x
->lock
);
396 skb_shinfo(skb
)->nr_frags
= 1;
400 /* replace page frags in skb with new page */
401 __skb_fill_page_desc(skb
, 0, page
, pfrag
->offset
, skb
->data_len
);
402 pfrag
->offset
= pfrag
->offset
+ allocsize
;
403 spin_unlock_bh(&x
->lock
);
405 sg_init_table(dsg
, skb_shinfo(skb
)->nr_frags
+ 1);
406 skb_to_sgvec(skb
, dsg
,
407 (unsigned char *)esph
- skb
->data
,
408 assoclen
+ ivlen
+ esp
->clen
+ alen
);
411 if ((x
->props
.flags
& XFRM_STATE_ESN
))
412 aead_request_set_callback(req
, 0, esp_output_done_esn
, skb
);
414 aead_request_set_callback(req
, 0, esp_output_done
, skb
);
416 aead_request_set_crypt(req
, sg
, dsg
, ivlen
+ esp
->clen
, iv
);
417 aead_request_set_ad(req
, assoclen
);
419 memset(iv
, 0, ivlen
);
420 memcpy(iv
+ ivlen
- min(ivlen
, 8), (u8
*)&esp
->seqno
+ 8 - min(ivlen
, 8),
423 ESP_SKB_CB(skb
)->tmp
= tmp
;
424 err
= crypto_aead_encrypt(req
);
435 if ((x
->props
.flags
& XFRM_STATE_ESN
))
436 esp_output_restore_header(skb
);
440 esp_ssg_unref(x
, tmp
);
446 EXPORT_SYMBOL_GPL(esp_output_tail
);
448 static int esp_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
452 struct ip_esp_hdr
*esph
;
453 struct crypto_aead
*aead
;
458 esp
.proto
= *skb_mac_header(skb
);
459 *skb_mac_header(skb
) = IPPROTO_ESP
;
461 /* skb is pure payload to encrypt */
464 alen
= crypto_aead_authsize(aead
);
468 struct xfrm_dst
*dst
= (struct xfrm_dst
*)skb_dst(skb
);
471 padto
= min(x
->tfcpad
, esp4_get_mtu(x
, dst
->child_mtu_cached
));
472 if (skb
->len
< padto
)
473 esp
.tfclen
= padto
- skb
->len
;
475 blksize
= ALIGN(crypto_aead_blocksize(aead
), 4);
476 esp
.clen
= ALIGN(skb
->len
+ 2 + esp
.tfclen
, blksize
);
477 esp
.plen
= esp
.clen
- skb
->len
- esp
.tfclen
;
478 esp
.tailen
= esp
.tfclen
+ esp
.plen
+ alen
;
480 esp
.esph
= ip_esp_hdr(skb
);
482 esp
.nfrags
= esp_output_head(x
, skb
, &esp
);
487 esph
->spi
= x
->id
.spi
;
489 esph
->seq_no
= htonl(XFRM_SKB_CB(skb
)->seq
.output
.low
);
490 esp
.seqno
= cpu_to_be64(XFRM_SKB_CB(skb
)->seq
.output
.low
+
491 ((u64
)XFRM_SKB_CB(skb
)->seq
.output
.hi
<< 32));
493 skb_push(skb
, -skb_network_offset(skb
));
495 return esp_output_tail(x
, skb
, &esp
);
498 int esp_input_done2(struct sk_buff
*skb
, int err
)
500 const struct iphdr
*iph
;
501 struct xfrm_state
*x
= xfrm_input_state(skb
);
502 struct xfrm_offload
*xo
= xfrm_offload(skb
);
503 struct crypto_aead
*aead
= x
->data
;
504 int alen
= crypto_aead_authsize(aead
);
505 int hlen
= sizeof(struct ip_esp_hdr
) + crypto_aead_ivsize(aead
);
506 int elen
= skb
->len
- hlen
;
511 if (!xo
|| (xo
&& !(xo
->flags
& CRYPTO_DONE
)))
512 kfree(ESP_SKB_CB(skb
)->tmp
);
517 if (skb_copy_bits(skb
, skb
->len
-alen
-2, nexthdr
, 2))
522 if (padlen
+ 2 + alen
>= elen
)
525 /* ... check padding bits here. Silly. :-) */
531 struct xfrm_encap_tmpl
*encap
= x
->encap
;
532 struct udphdr
*uh
= (void *)(skb_network_header(skb
) + ihl
);
535 * 1) if the NAT-T peer's IP or port changed then
536 * advertize the change to the keying daemon.
537 * This is an inbound SA, so just compare
540 if (iph
->saddr
!= x
->props
.saddr
.a4
||
541 uh
->source
!= encap
->encap_sport
) {
542 xfrm_address_t ipaddr
;
544 ipaddr
.a4
= iph
->saddr
;
545 km_new_mapping(x
, &ipaddr
, uh
->source
);
547 /* XXX: perhaps add an extra
548 * policy check here, to see
549 * if we should allow or
550 * reject a packet from a
557 * 2) ignore UDP/TCP checksums in case
558 * of NAT-T in Transport Mode, or
559 * perform other post-processing fixes
560 * as per draft-ietf-ipsec-udp-encaps-06,
563 if (x
->props
.mode
== XFRM_MODE_TRANSPORT
)
564 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
567 pskb_trim(skb
, skb
->len
- alen
- padlen
- 2);
568 __skb_pull(skb
, hlen
);
569 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
570 skb_reset_transport_header(skb
);
572 skb_set_transport_header(skb
, -ihl
);
576 /* RFC4303: Drop dummy packets without any error */
577 if (err
== IPPROTO_NONE
)
583 EXPORT_SYMBOL_GPL(esp_input_done2
);
585 static void esp_input_done(struct crypto_async_request
*base
, int err
)
587 struct sk_buff
*skb
= base
->data
;
589 xfrm_input_resume(skb
, esp_input_done2(skb
, err
));
592 static void esp_input_restore_header(struct sk_buff
*skb
)
594 esp_restore_header(skb
, 0);
598 static void esp_input_set_header(struct sk_buff
*skb
, __be32
*seqhi
)
600 struct xfrm_state
*x
= xfrm_input_state(skb
);
601 struct ip_esp_hdr
*esph
= (struct ip_esp_hdr
*)skb
->data
;
603 /* For ESN we move the header forward by 4 bytes to
604 * accomodate the high bits. We will move it back after
607 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
608 esph
= (void *)skb_push(skb
, 4);
610 esph
->spi
= esph
->seq_no
;
611 esph
->seq_no
= XFRM_SKB_CB(skb
)->seq
.input
.hi
;
615 static void esp_input_done_esn(struct crypto_async_request
*base
, int err
)
617 struct sk_buff
*skb
= base
->data
;
619 esp_input_restore_header(skb
);
620 esp_input_done(base
, err
);
624 * Note: detecting truncated vs. non-truncated authentication data is very
625 * expensive, so we only support truncated data, which is the recommended
628 static int esp_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
630 struct ip_esp_hdr
*esph
;
631 struct crypto_aead
*aead
= x
->data
;
632 struct aead_request
*req
;
633 struct sk_buff
*trailer
;
634 int ivlen
= crypto_aead_ivsize(aead
);
635 int elen
= skb
->len
- sizeof(*esph
) - ivlen
;
642 struct scatterlist
*sg
;
645 if (!pskb_may_pull(skb
, sizeof(*esph
) + ivlen
))
651 assoclen
= sizeof(*esph
);
654 if (x
->props
.flags
& XFRM_STATE_ESN
) {
655 seqhilen
+= sizeof(__be32
);
656 assoclen
+= seqhilen
;
659 if (!skb_cloned(skb
)) {
660 if (!skb_is_nonlinear(skb
)) {
664 } else if (!skb_has_frag_list(skb
)) {
665 nfrags
= skb_shinfo(skb
)->nr_frags
;
672 err
= skb_cow_data(skb
, 0, &trailer
);
680 tmp
= esp_alloc_tmp(aead
, nfrags
, seqhilen
);
684 ESP_SKB_CB(skb
)->tmp
= tmp
;
685 seqhi
= esp_tmp_extra(tmp
);
686 iv
= esp_tmp_iv(aead
, tmp
, seqhilen
);
687 req
= esp_tmp_req(aead
, iv
);
688 sg
= esp_req_sg(aead
, req
);
690 esp_input_set_header(skb
, seqhi
);
692 sg_init_table(sg
, nfrags
);
693 skb_to_sgvec(skb
, sg
, 0, skb
->len
);
695 skb
->ip_summed
= CHECKSUM_NONE
;
697 if ((x
->props
.flags
& XFRM_STATE_ESN
))
698 aead_request_set_callback(req
, 0, esp_input_done_esn
, skb
);
700 aead_request_set_callback(req
, 0, esp_input_done
, skb
);
702 aead_request_set_crypt(req
, sg
, sg
, elen
+ ivlen
, iv
);
703 aead_request_set_ad(req
, assoclen
);
705 err
= crypto_aead_decrypt(req
);
706 if (err
== -EINPROGRESS
)
709 if ((x
->props
.flags
& XFRM_STATE_ESN
))
710 esp_input_restore_header(skb
);
712 err
= esp_input_done2(skb
, err
);
718 static u32
esp4_get_mtu(struct xfrm_state
*x
, int mtu
)
720 struct crypto_aead
*aead
= x
->data
;
721 u32 blksize
= ALIGN(crypto_aead_blocksize(aead
), 4);
722 unsigned int net_adj
;
724 switch (x
->props
.mode
) {
725 case XFRM_MODE_TRANSPORT
:
727 net_adj
= sizeof(struct iphdr
);
729 case XFRM_MODE_TUNNEL
:
736 return ((mtu
- x
->props
.header_len
- crypto_aead_authsize(aead
) -
737 net_adj
) & ~(blksize
- 1)) + net_adj
- 2;
740 static int esp4_err(struct sk_buff
*skb
, u32 info
)
742 struct net
*net
= dev_net(skb
->dev
);
743 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
744 struct ip_esp_hdr
*esph
= (struct ip_esp_hdr
*)(skb
->data
+(iph
->ihl
<<2));
745 struct xfrm_state
*x
;
747 switch (icmp_hdr(skb
)->type
) {
748 case ICMP_DEST_UNREACH
:
749 if (icmp_hdr(skb
)->code
!= ICMP_FRAG_NEEDED
)
757 x
= xfrm_state_lookup(net
, skb
->mark
, (const xfrm_address_t
*)&iph
->daddr
,
758 esph
->spi
, IPPROTO_ESP
, AF_INET
);
762 if (icmp_hdr(skb
)->type
== ICMP_DEST_UNREACH
)
763 ipv4_update_pmtu(skb
, net
, info
, 0, 0, IPPROTO_ESP
, 0);
765 ipv4_redirect(skb
, net
, 0, 0, IPPROTO_ESP
, 0);
771 static void esp_destroy(struct xfrm_state
*x
)
773 struct crypto_aead
*aead
= x
->data
;
778 crypto_free_aead(aead
);
781 static int esp_init_aead(struct xfrm_state
*x
)
783 char aead_name
[CRYPTO_MAX_ALG_NAME
];
784 struct crypto_aead
*aead
;
789 if (snprintf(aead_name
, CRYPTO_MAX_ALG_NAME
, "%s(%s)",
790 x
->geniv
, x
->aead
->alg_name
) >= CRYPTO_MAX_ALG_NAME
)
793 if (x
->xso
.offload_handle
)
794 mask
|= CRYPTO_ALG_ASYNC
;
796 aead
= crypto_alloc_aead(aead_name
, 0, mask
);
803 err
= crypto_aead_setkey(aead
, x
->aead
->alg_key
,
804 (x
->aead
->alg_key_len
+ 7) / 8);
808 err
= crypto_aead_setauthsize(aead
, x
->aead
->alg_icv_len
/ 8);
816 static int esp_init_authenc(struct xfrm_state
*x
)
818 struct crypto_aead
*aead
;
819 struct crypto_authenc_key_param
*param
;
823 char authenc_name
[CRYPTO_MAX_ALG_NAME
];
834 if ((x
->props
.flags
& XFRM_STATE_ESN
)) {
835 if (snprintf(authenc_name
, CRYPTO_MAX_ALG_NAME
,
836 "%s%sauthencesn(%s,%s)%s",
837 x
->geniv
?: "", x
->geniv
? "(" : "",
838 x
->aalg
? x
->aalg
->alg_name
: "digest_null",
840 x
->geniv
? ")" : "") >= CRYPTO_MAX_ALG_NAME
)
843 if (snprintf(authenc_name
, CRYPTO_MAX_ALG_NAME
,
844 "%s%sauthenc(%s,%s)%s",
845 x
->geniv
?: "", x
->geniv
? "(" : "",
846 x
->aalg
? x
->aalg
->alg_name
: "digest_null",
848 x
->geniv
? ")" : "") >= CRYPTO_MAX_ALG_NAME
)
852 if (x
->xso
.offload_handle
)
853 mask
|= CRYPTO_ALG_ASYNC
;
855 aead
= crypto_alloc_aead(authenc_name
, 0, mask
);
862 keylen
= (x
->aalg
? (x
->aalg
->alg_key_len
+ 7) / 8 : 0) +
863 (x
->ealg
->alg_key_len
+ 7) / 8 + RTA_SPACE(sizeof(*param
));
865 key
= kmalloc(keylen
, GFP_KERNEL
);
871 rta
->rta_type
= CRYPTO_AUTHENC_KEYA_PARAM
;
872 rta
->rta_len
= RTA_LENGTH(sizeof(*param
));
873 param
= RTA_DATA(rta
);
874 p
+= RTA_SPACE(sizeof(*param
));
877 struct xfrm_algo_desc
*aalg_desc
;
879 memcpy(p
, x
->aalg
->alg_key
, (x
->aalg
->alg_key_len
+ 7) / 8);
880 p
+= (x
->aalg
->alg_key_len
+ 7) / 8;
882 aalg_desc
= xfrm_aalg_get_byname(x
->aalg
->alg_name
, 0);
886 if (aalg_desc
->uinfo
.auth
.icv_fullbits
/ 8 !=
887 crypto_aead_authsize(aead
)) {
888 pr_info("ESP: %s digestsize %u != %hu\n",
890 crypto_aead_authsize(aead
),
891 aalg_desc
->uinfo
.auth
.icv_fullbits
/ 8);
895 err
= crypto_aead_setauthsize(
896 aead
, x
->aalg
->alg_trunc_len
/ 8);
901 param
->enckeylen
= cpu_to_be32((x
->ealg
->alg_key_len
+ 7) / 8);
902 memcpy(p
, x
->ealg
->alg_key
, (x
->ealg
->alg_key_len
+ 7) / 8);
904 err
= crypto_aead_setkey(aead
, key
, keylen
);
913 static int esp_init_state(struct xfrm_state
*x
)
915 struct crypto_aead
*aead
;
922 err
= esp_init_aead(x
);
924 err
= esp_init_authenc(x
);
931 x
->props
.header_len
= sizeof(struct ip_esp_hdr
) +
932 crypto_aead_ivsize(aead
);
933 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
934 x
->props
.header_len
+= sizeof(struct iphdr
);
935 else if (x
->props
.mode
== XFRM_MODE_BEET
&& x
->sel
.family
!= AF_INET6
)
936 x
->props
.header_len
+= IPV4_BEET_PHMAXLEN
;
938 struct xfrm_encap_tmpl
*encap
= x
->encap
;
940 switch (encap
->encap_type
) {
943 case UDP_ENCAP_ESPINUDP
:
944 x
->props
.header_len
+= sizeof(struct udphdr
);
946 case UDP_ENCAP_ESPINUDP_NON_IKE
:
947 x
->props
.header_len
+= sizeof(struct udphdr
) + 2 * sizeof(u32
);
952 align
= ALIGN(crypto_aead_blocksize(aead
), 4);
953 x
->props
.trailer_len
= align
+ 1 + crypto_aead_authsize(aead
);
959 static int esp4_rcv_cb(struct sk_buff
*skb
, int err
)
964 static const struct xfrm_type esp_type
=
966 .description
= "ESP4",
967 .owner
= THIS_MODULE
,
968 .proto
= IPPROTO_ESP
,
969 .flags
= XFRM_TYPE_REPLAY_PROT
,
970 .init_state
= esp_init_state
,
971 .destructor
= esp_destroy
,
972 .get_mtu
= esp4_get_mtu
,
974 .output
= esp_output
,
977 static struct xfrm4_protocol esp4_protocol
= {
978 .handler
= xfrm4_rcv
,
979 .input_handler
= xfrm_input
,
980 .cb_handler
= esp4_rcv_cb
,
981 .err_handler
= esp4_err
,
985 static int __init
esp4_init(void)
987 if (xfrm_register_type(&esp_type
, AF_INET
) < 0) {
988 pr_info("%s: can't add xfrm type\n", __func__
);
991 if (xfrm4_protocol_register(&esp4_protocol
, IPPROTO_ESP
) < 0) {
992 pr_info("%s: can't add protocol\n", __func__
);
993 xfrm_unregister_type(&esp_type
, AF_INET
);
999 static void __exit
esp4_fini(void)
1001 if (xfrm4_protocol_deregister(&esp4_protocol
, IPPROTO_ESP
) < 0)
1002 pr_info("%s: can't remove protocol\n", __func__
);
1003 if (xfrm_unregister_type(&esp_type
, AF_INET
) < 0)
1004 pr_info("%s: can't remove xfrm type\n", __func__
);
1007 module_init(esp4_init
);
1008 module_exit(esp4_fini
);
1009 MODULE_LICENSE("GPL");
1010 MODULE_ALIAS_XFRM_TYPE(AF_INET
, XFRM_PROTO_ESP
);