src/vnet/ipsec/esp.h

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #ifndef __ESP_H__
  16 #define __ESP_H__
  17
  18 #include <vnet/ip/ip.h>
  19 #include <vnet/crypto/crypto.h>
  20 #include <vnet/ipsec/ipsec.h>
  21 #include <vnet/ipsec/ipsec.api_enum.h>
  22
  23 typedef struct
  24 {
  25   union
  26   {
  27     u32 spi;
  28     u8 spi_bytes[4];
  29   };
  30   u32 seq;
  31   u8 data[0];
  32 } esp_header_t;
  33
  34 typedef struct
  35 {
  36   u8 pad_length;
  37   u8 next_header;
  38 } esp_footer_t;
  39
  40 /* *INDENT-OFF* */
  41 typedef CLIB_PACKED (struct {
  42   ip4_header_t ip4;
  43   esp_header_t esp;
  44 }) ip4_and_esp_header_t;
  45 /* *INDENT-ON* */
  46
  47 /* *INDENT-OFF* */
  48 typedef CLIB_PACKED (struct {
  49   ip4_header_t ip4;
  50   udp_header_t udp;
  51   esp_header_t esp;
  52 }) ip4_and_udp_and_esp_header_t;
  53 /* *INDENT-ON* */
  54
  55 /* *INDENT-OFF* */
  56 typedef CLIB_PACKED (struct {
  57   ip6_header_t ip6;
  58   esp_header_t esp;
  59 }) ip6_and_esp_header_t;
  60 /* *INDENT-ON* */
  61
  62 /**
  63  * AES counter mode nonce
  64  */
  65 typedef struct
  66 {
  67   u32 salt;
  68   u64 iv;
  69   u32 ctr; /* counter: 1 in big-endian for ctr, unused for gcm */
  70 } __clib_packed esp_ctr_nonce_t;
  71
  72 STATIC_ASSERT_SIZEOF (esp_ctr_nonce_t, 16);
  73
  74 /**
  75  * AES GCM Additional Authentication data
  76  */
  77 typedef struct esp_aead_t_
  78 {
  79   /**
  80    * for GCM: when using ESN it's:
  81    *   SPI, seq-hi, seg-low
  82    * else
  83    *   SPI, seq-low
  84    */
  85   u32 data[3];
  86 } __clib_packed esp_aead_t;
  87
  88 #define ESP_SEQ_MAX             (4294967295UL)
  89
  90 u8 *format_esp_header (u8 * s, va_list * args);
  91
  92 /* TODO seq increment should be atomic to be accessed by multiple workers */
  93 always_inline int
  94 esp_seq_advance (ipsec_sa_t * sa)
  95 {
  96   if (PREDICT_TRUE (ipsec_sa_is_set_USE_ESN (sa)))
  97     {
  98       if (PREDICT_FALSE (sa->seq == ESP_SEQ_MAX))
  99         {
 100           if (PREDICT_FALSE (ipsec_sa_is_set_USE_ANTI_REPLAY (sa) &&
 101                              sa->seq_hi == ESP_SEQ_MAX))
 102             return 1;
 103           sa->seq_hi++;
 104         }
 105       sa->seq++;
 106     }
 107   else
 108     {
 109       if (PREDICT_FALSE (ipsec_sa_is_set_USE_ANTI_REPLAY (sa) &&
 110                          sa->seq == ESP_SEQ_MAX))
 111         return 1;
 112       sa->seq++;
 113     }
 114
 115   return 0;
 116 }
 117
 118 always_inline u16
 119 esp_aad_fill (u8 *data, const esp_header_t *esp, const ipsec_sa_t *sa,
 120               u32 seq_hi)
 121 {
 122   esp_aead_t *aad;
 123
 124   aad = (esp_aead_t *) data;
 125   aad->data[0] = esp->spi;
 126
 127   if (ipsec_sa_is_set_USE_ESN (sa))
 128     {
 129       /* SPI, seq-hi, seq-low */
 130       aad->data[1] = (u32) clib_host_to_net_u32 (seq_hi);
 131       aad->data[2] = esp->seq;
 132       return 12;
 133     }
 134   else
 135     {
 136       /* SPI, seq-low */
 137       aad->data[1] = esp->seq;
 138       return 8;
 139     }
 140 }
 141
 142 always_inline u32
 143 esp_encrypt_err_to_sa_err (u32 err)
 144 {
 145   switch (err)
 146     {
 147     case ESP_ENCRYPT_ERROR_HANDOFF:
 148       return IPSEC_SA_ERROR_HANDOFF;
 149     case ESP_ENCRYPT_ERROR_SEQ_CYCLED:
 150       return IPSEC_SA_ERROR_SEQ_CYCLED;
 151     case ESP_ENCRYPT_ERROR_CRYPTO_ENGINE_ERROR:
 152       return IPSEC_SA_ERROR_CRYPTO_ENGINE_ERROR;
 153     case ESP_ENCRYPT_ERROR_CRYPTO_QUEUE_FULL:
 154       return IPSEC_SA_ERROR_CRYPTO_QUEUE_FULL;
 155     case ESP_ENCRYPT_ERROR_NO_BUFFERS:
 156       return IPSEC_SA_ERROR_NO_BUFFERS;
 157     case ESP_ENCRYPT_ERROR_NO_ENCRYPTION:
 158       return IPSEC_SA_ERROR_NO_ENCRYPTION;
 159     }
 160   return ~0;
 161 }
 162
 163 always_inline u32
 164 esp_decrypt_err_to_sa_err (u32 err)
 165 {
 166   switch (err)
 167     {
 168     case ESP_DECRYPT_ERROR_HANDOFF:
 169       return IPSEC_SA_ERROR_HANDOFF;
 170     case ESP_DECRYPT_ERROR_DECRYPTION_FAILED:
 171       return IPSEC_SA_ERROR_DECRYPTION_FAILED;
 172     case ESP_DECRYPT_ERROR_INTEG_ERROR:
 173       return IPSEC_SA_ERROR_INTEG_ERROR;
 174     case ESP_DECRYPT_ERROR_CRYPTO_ENGINE_ERROR:
 175       return IPSEC_SA_ERROR_CRYPTO_ENGINE_ERROR;
 176     case ESP_DECRYPT_ERROR_REPLAY:
 177       return IPSEC_SA_ERROR_REPLAY;
 178     case ESP_DECRYPT_ERROR_RUNT:
 179       return IPSEC_SA_ERROR_RUNT;
 180     case ESP_DECRYPT_ERROR_NO_BUFFERS:
 181       return IPSEC_SA_ERROR_NO_BUFFERS;
 182     case ESP_DECRYPT_ERROR_OVERSIZED_HEADER:
 183       return IPSEC_SA_ERROR_OVERSIZED_HEADER;
 184     case ESP_DECRYPT_ERROR_NO_TAIL_SPACE:
 185       return IPSEC_SA_ERROR_NO_TAIL_SPACE;
 186     case ESP_DECRYPT_ERROR_TUN_NO_PROTO:
 187       return IPSEC_SA_ERROR_TUN_NO_PROTO;
 188     case ESP_DECRYPT_ERROR_UNSUP_PAYLOAD:
 189       return IPSEC_SA_ERROR_UNSUP_PAYLOAD;
 190     }
 191   return ~0;
 192 }
 193
 194 always_inline void
 195 esp_encrypt_set_next_index (vlib_buffer_t *b, vlib_node_runtime_t *node,
 196                             u32 thread_index, u32 err, u16 index, u16 *nexts,
 197                             u16 drop_next, u32 sa_index)
 198 {
 199   ipsec_set_next_index (b, node, thread_index, err,
 200                         esp_encrypt_err_to_sa_err (err), index, nexts,
 201                         drop_next, sa_index);
 202 }
 203
 204 always_inline void
 205 esp_decrypt_set_next_index (vlib_buffer_t *b, vlib_node_runtime_t *node,
 206                             u32 thread_index, u32 err, u16 index, u16 *nexts,
 207                             u16 drop_next, u32 sa_index)
 208 {
 209   ipsec_set_next_index (b, node, thread_index, err,
 210                         esp_decrypt_err_to_sa_err (err), index, nexts,
 211                         drop_next, sa_index);
 212 }
 213
 214 /* when submitting a frame is failed, drop all buffers in the frame */
 215 always_inline u32
 216 esp_async_recycle_failed_submit (vlib_main_t *vm, vnet_crypto_async_frame_t *f,
 217                                  vlib_node_runtime_t *node, u32 err,
 218                                  u32 ipsec_sa_err, u16 index, u32 *from,
 219                                  u16 *nexts, u16 drop_next_index)
 220 {
 221   vlib_buffer_t *b;
 222   u32 n_drop = f->n_elts;
 223   u32 *bi = f->buffer_indices;
 224
 225   while (n_drop--)
 226     {
 227       from[index] = bi[0];
 228       b = vlib_get_buffer (vm, bi[0]);
 229       ipsec_set_next_index (b, node, vm->thread_index, err, ipsec_sa_err,
 230                             index, nexts, drop_next_index,
 231                             vnet_buffer (b)->ipsec.sad_index);
 232       bi++;
 233       index++;
 234     }
 235
 236   return (f->n_elts);
 237 }
 238
 239 /**
 240  * The post data structure to for esp_encrypt/decrypt_inline to write to
 241  * vib_buffer_t opaque unused field, and for post nodes to pick up after
 242  * dequeue.
 243  **/
 244 typedef struct
 245 {
 246   union
 247   {
 248     struct
 249     {
 250       u8 icv_sz;
 251       u8 iv_sz;
 252       ipsec_sa_flags_t flags;
 253       u32 sa_index;
 254     };
 255     u64 sa_data;
 256   };
 257
 258   u32 seq;
 259   i16 current_data;
 260   i16 current_length;
 261   u16 hdr_sz;
 262   u16 is_chain;
 263   u32 seq_hi;
 264 } esp_decrypt_packet_data_t;
 265
 266 STATIC_ASSERT_SIZEOF (esp_decrypt_packet_data_t, 3 * sizeof (u64));
 267 STATIC_ASSERT_OFFSET_OF (esp_decrypt_packet_data_t, seq, sizeof (u64));
 268
 269 /* we are forced to store the decrypt post data into 2 separate places -
 270    vlib_opaque and opaque2. */
 271 typedef struct
 272 {
 273   vlib_buffer_t *lb;
 274   u32 free_buffer_index;
 275   u8 icv_removed;
 276 } esp_decrypt_packet_data2_t;
 277
 278 typedef union
 279 {
 280   u16 next_index;
 281   esp_decrypt_packet_data_t decrypt_data;
 282 } esp_post_data_t;
 283
 284 STATIC_ASSERT (sizeof (esp_post_data_t) <=
 285                STRUCT_SIZE_OF (vnet_buffer_opaque_t, unused),
 286                "Custom meta-data too large for vnet_buffer_opaque_t");
 287
 288 #define esp_post_data(b) \
 289     ((esp_post_data_t *)((u8 *)((b)->opaque) \
 290         + STRUCT_OFFSET_OF (vnet_buffer_opaque_t, unused)))
 291
 292 STATIC_ASSERT (sizeof (esp_decrypt_packet_data2_t) <=
 293                STRUCT_SIZE_OF (vnet_buffer_opaque2_t, unused),
 294                "Custom meta-data too large for vnet_buffer_opaque2_t");
 295
 296 #define esp_post_data2(b) \
 297     ((esp_decrypt_packet_data2_t *)((u8 *)((b)->opaque2) \
 298         + STRUCT_OFFSET_OF (vnet_buffer_opaque2_t, unused)))
 299
 300 typedef struct
 301 {
 302   /* esp post node index for async crypto */
 303   u32 esp4_post_next;
 304   u32 esp6_post_next;
 305   u32 esp4_tun_post_next;
 306   u32 esp6_tun_post_next;
 307   u32 esp_mpls_tun_post_next;
 308 } esp_async_post_next_t;
 309
 310 extern esp_async_post_next_t esp_encrypt_async_next;
 311 extern esp_async_post_next_t esp_decrypt_async_next;
 312
 313 #endif /* __ESP_H__ */
 314
 315 /*
 316  * fd.io coding-style-patch-verification: ON
 317  *
 318  * Local Variables:
 319  * eval: (c-set-style "gnu")
 320  * End:
 321  */