net/ipv6/esp6_offload.c

   1 /*
   2  * IPV6 GSO/GRO offload support
   3  * Linux INET implementation
   4  *
   5  * Copyright (C) 2016 secunet Security Networks AG
   6  * Author: Steffen Klassert <steffen.klassert@secunet.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms and conditions of the GNU General Public License,
  10  * version 2, as published by the Free Software Foundation.
  11  *
  12  * ESP GRO support
  13  */
  14
  15 #include <linux/skbuff.h>
  16 #include <linux/init.h>
  17 #include <net/protocol.h>
  18 #include <crypto/aead.h>
  19 #include <crypto/authenc.h>
  20 #include <linux/err.h>
  21 #include <linux/module.h>
  22 #include <net/ip.h>
  23 #include <net/xfrm.h>
  24 #include <net/esp.h>
  25 #include <linux/scatterlist.h>
  26 #include <linux/kernel.h>
  27 #include <linux/slab.h>
  28 #include <linux/spinlock.h>
  29 #include <net/ip6_route.h>
  30 #include <net/ipv6.h>
  31 #include <linux/icmpv6.h>
  32
  33 static __u16 esp6_nexthdr_esp_offset(struct ipv6hdr *ipv6_hdr, int nhlen)
  34 {
  35         int off = sizeof(struct ipv6hdr);
  36         struct ipv6_opt_hdr *exthdr;
  37
  38         if (likely(ipv6_hdr->nexthdr == NEXTHDR_ESP))
  39                 return offsetof(struct ipv6hdr, nexthdr);
  40
  41         while (off < nhlen) {
  42                 exthdr = (void *)ipv6_hdr + off;
  43                 if (exthdr->nexthdr == NEXTHDR_ESP)
  44                         return off;
  45
  46                 off += ipv6_optlen(exthdr);
  47         }
  48
  49         return 0;
  50 }
  51
  52 static struct sk_buff **esp6_gro_receive(struct sk_buff **head,
  53                                          struct sk_buff *skb)
  54 {
  55         int offset = skb_gro_offset(skb);
  56         struct xfrm_offload *xo;
  57         struct xfrm_state *x;
  58         __be32 seq;
  59         __be32 spi;
  60         int nhoff;
  61         int err;
  62
  63         skb_pull(skb, offset);
  64
  65         if ((err = xfrm_parse_spi(skb, IPPROTO_ESP, &spi, &seq)) != 0)
  66                 goto out;
  67
  68         xo = xfrm_offload(skb);
  69         if (!xo || !(xo->flags & CRYPTO_DONE)) {
  70                 err = secpath_set(skb);
  71                 if (err)
  72                         goto out;
  73
  74                 if (skb->sp->len == XFRM_MAX_DEPTH)
  75                         goto out;
  76
  77                 x = xfrm_state_lookup(dev_net(skb->dev), skb->mark,
  78                                       (xfrm_address_t *)&ipv6_hdr(skb)->daddr,
  79                                       spi, IPPROTO_ESP, AF_INET6);
  80                 if (!x)
  81                         goto out;
  82
  83                 skb->sp->xvec[skb->sp->len++] = x;
  84                 skb->sp->olen++;
  85
  86                 xo = xfrm_offload(skb);
  87                 if (!xo) {
  88                         xfrm_state_put(x);
  89                         goto out;
  90                 }
  91         }
  92
  93         xo->flags |= XFRM_GRO;
  94
  95         nhoff = esp6_nexthdr_esp_offset(ipv6_hdr(skb), offset);
  96         if (!nhoff)
  97                 goto out;
  98
  99         IP6CB(skb)->nhoff = nhoff;
 100         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL;
 101         XFRM_SPI_SKB_CB(skb)->family = AF_INET6;
 102         XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct ipv6hdr, daddr);
 103         XFRM_SPI_SKB_CB(skb)->seq = seq;
 104
 105         /* We don't need to handle errors from xfrm_input, it does all
 106          * the error handling and frees the resources on error. */
 107         xfrm_input(skb, IPPROTO_ESP, spi, -2);
 108
 109         return ERR_PTR(-EINPROGRESS);
 110 out:
 111         skb_push(skb, offset);
 112         NAPI_GRO_CB(skb)->same_flow = 0;
 113         NAPI_GRO_CB(skb)->flush = 1;
 114
 115         return NULL;
 116 }
 117
 118 static void esp6_gso_encap(struct xfrm_state *x, struct sk_buff *skb)
 119 {
 120         struct ip_esp_hdr *esph;
 121         struct ipv6hdr *iph = ipv6_hdr(skb);
 122         struct xfrm_offload *xo = xfrm_offload(skb);
 123         int proto = iph->nexthdr;
 124
 125         skb_push(skb, -skb_network_offset(skb));
 126         esph = ip_esp_hdr(skb);
 127         *skb_mac_header(skb) = IPPROTO_ESP;
 128
 129         esph->spi = x->id.spi;
 130         esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low);
 131
 132         xo->proto = proto;
 133 }
 134
 135 static struct sk_buff *esp6_gso_segment(struct sk_buff *skb,
 136                                         netdev_features_t features)
 137 {
 138         __u32 seq;
 139         int err = 0;
 140         struct sk_buff *skb2;
 141         struct xfrm_state *x;
 142         struct ip_esp_hdr *esph;
 143         struct crypto_aead *aead;
 144         struct sk_buff *segs = ERR_PTR(-EINVAL);
 145         netdev_features_t esp_features = features;
 146         struct xfrm_offload *xo = xfrm_offload(skb);
 147
 148         if (!xo)
 149                 goto out;
 150
 151         seq = xo->seq.low;
 152
 153         x = skb->sp->xvec[skb->sp->len - 1];
 154         aead = x->data;
 155         esph = ip_esp_hdr(skb);
 156
 157         if (esph->spi != x->id.spi)
 158                 goto out;
 159
 160         if (!pskb_may_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead)))
 161                 goto out;
 162
 163         __skb_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead));
 164
 165         skb->encap_hdr_csum = 1;
 166
 167         if (!(features & NETIF_F_HW_ESP))
 168                 esp_features = features & ~(NETIF_F_SG | NETIF_F_CSUM_MASK);
 169
 170         segs = x->outer_mode->gso_segment(x, skb, esp_features);
 171         if (IS_ERR_OR_NULL(segs))
 172                 goto out;
 173
 174         __skb_pull(skb, skb->data - skb_mac_header(skb));
 175
 176         skb2 = segs;
 177         do {
 178                 struct sk_buff *nskb = skb2->next;
 179
 180                 xo = xfrm_offload(skb2);
 181                 xo->flags |= XFRM_GSO_SEGMENT;
 182                 xo->seq.low = seq;
 183                 xo->seq.hi = xfrm_replay_seqhi(x, seq);
 184
 185                 if(!(features & NETIF_F_HW_ESP))
 186                         xo->flags |= CRYPTO_FALLBACK;
 187
 188                 x->outer_mode->xmit(x, skb2);
 189
 190                 err = x->type_offload->xmit(x, skb2, esp_features);
 191                 if (err) {
 192                         kfree_skb_list(segs);
 193                         return ERR_PTR(err);
 194                 }
 195
 196                 if (!skb_is_gso(skb2))
 197                         seq++;
 198                 else
 199                         seq += skb_shinfo(skb2)->gso_segs;
 200
 201                 skb_push(skb2, skb2->mac_len);
 202                 skb2 = nskb;
 203         } while (skb2);
 204
 205 out:
 206         return segs;
 207 }
 208
 209 static int esp6_input_tail(struct xfrm_state *x, struct sk_buff *skb)
 210 {
 211         struct crypto_aead *aead = x->data;
 212
 213         if (!pskb_may_pull(skb, sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead)))
 214                 return -EINVAL;
 215
 216         skb->ip_summed = CHECKSUM_NONE;
 217
 218         return esp6_input_done2(skb, 0);
 219 }
 220
 221 static int esp6_xmit(struct xfrm_state *x, struct sk_buff *skb,  netdev_features_t features)
 222 {
 223         int err;
 224         int alen;
 225         int blksize;
 226         struct xfrm_offload *xo;
 227         struct ip_esp_hdr *esph;
 228         struct crypto_aead *aead;
 229         struct esp_info esp;
 230         bool hw_offload = true;
 231
 232         esp.inplace = true;
 233
 234         xo = xfrm_offload(skb);
 235
 236         if (!xo)
 237                 return -EINVAL;
 238
 239         if (!(features & NETIF_F_HW_ESP) || !x->xso.offload_handle ||
 240             (x->xso.dev != skb->dev)) {
 241                 xo->flags |= CRYPTO_FALLBACK;
 242                 hw_offload = false;
 243         }
 244
 245         esp.proto = xo->proto;
 246
 247         /* skb is pure payload to encrypt */
 248
 249         aead = x->data;
 250         alen = crypto_aead_authsize(aead);
 251
 252         esp.tfclen = 0;
 253         /* XXX: Add support for tfc padding here. */
 254
 255         blksize = ALIGN(crypto_aead_blocksize(aead), 4);
 256         esp.clen = ALIGN(skb->len + 2 + esp.tfclen, blksize);
 257         esp.plen = esp.clen - skb->len - esp.tfclen;
 258         esp.tailen = esp.tfclen + esp.plen + alen;
 259
 260         if (!hw_offload || (hw_offload && !skb_is_gso(skb))) {
 261                 esp.nfrags = esp6_output_head(x, skb, &esp);
 262                 if (esp.nfrags < 0)
 263                         return esp.nfrags;
 264         }
 265
 266         esph = ip_esp_hdr(skb);
 267         esph->spi = x->id.spi;
 268
 269         skb_push(skb, -skb_network_offset(skb));
 270
 271         if (xo->flags & XFRM_GSO_SEGMENT) {
 272                 esph->seq_no = htonl(xo->seq.low);
 273         } else {
 274                 int len;
 275
 276                 len = skb->len - sizeof(struct ipv6hdr);
 277                 if (len > IPV6_MAXPLEN)
 278                         len = 0;
 279
 280                 ipv6_hdr(skb)->payload_len = htons(len);
 281         }
 282
 283         if (hw_offload)
 284                 return 0;
 285
 286         esp.seqno = cpu_to_be64(xo->seq.low + ((u64)xo->seq.hi << 32));
 287
 288         err = esp6_output_tail(x, skb, &esp);
 289         if (err < 0)
 290                 return err;
 291
 292         secpath_reset(skb);
 293
 294         return 0;
 295 }
 296
 297 static const struct net_offload esp6_offload = {
 298         .callbacks = {
 299                 .gro_receive = esp6_gro_receive,
 300                 .gso_segment = esp6_gso_segment,
 301         },
 302 };
 303
 304 static const struct xfrm_type_offload esp6_type_offload = {
 305         .description    = "ESP6 OFFLOAD",
 306         .owner          = THIS_MODULE,
 307         .proto          = IPPROTO_ESP,
 308         .input_tail     = esp6_input_tail,
 309         .xmit           = esp6_xmit,
 310         .encap          = esp6_gso_encap,
 311 };
 312
 313 static int __init esp6_offload_init(void)
 314 {
 315         if (xfrm_register_type_offload(&esp6_type_offload, AF_INET6) < 0) {
 316                 pr_info("%s: can't add xfrm type offload\n", __func__);
 317                 return -EAGAIN;
 318         }
 319
 320         return inet6_add_offload(&esp6_offload, IPPROTO_ESP);
 321 }
 322
 323 static void __exit esp6_offload_exit(void)
 324 {
 325         if (xfrm_unregister_type_offload(&esp6_type_offload, AF_INET6) < 0)
 326                 pr_info("%s: can't remove xfrm type offload\n", __func__);
 327
 328         inet6_del_offload(&esp6_offload, IPPROTO_ESP);
 329 }
 330
 331 module_init(esp6_offload_init);
 332 module_exit(esp6_offload_exit);
 333 MODULE_LICENSE("GPL");
 334 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");