FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
esp_decrypt.c
Go to the documentation of this file.
1 /*
2  * esp_decrypt.c : IPSec ESP decrypt node
3  *
4  * Copyright (c) 2015 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vnet/vnet.h>
19 #include <vnet/api_errno.h>
20 #include <vnet/ip/ip.h>
21 
22 #include <vnet/ipsec/ipsec.h>
23 #include <vnet/ipsec/esp.h>
24 #include <vnet/ipsec/ipsec_io.h>
25 #include <vnet/ipsec/ipsec_tun.h>
26 
27 #define foreach_esp_decrypt_next \
28 _(DROP, "error-drop") \
29 _(IP4_INPUT, "ip4-input-no-checksum") \
30 _(IP6_INPUT, "ip6-input")
31 
32 #define _(v, s) ESP_DECRYPT_NEXT_##v,
33 typedef enum
34 {
36 #undef _
39 
40 
41 #define foreach_esp_decrypt_error \
42  _(RX_PKTS, "ESP pkts received") \
43  _(DECRYPTION_FAILED, "ESP decryption failed") \
44  _(INTEG_ERROR, "Integrity check failed") \
45  _(CRYPTO_ENGINE_ERROR, "crypto engine error (packet dropped)") \
46  _(REPLAY, "SA replayed packet") \
47  _(RUNT, "undersized packet") \
48  _(CHAINED_BUFFER, "chained buffers (packet dropped)") \
49  _(OVERSIZED_HEADER, "buffer with oversized header (dropped)") \
50  _(NO_TAIL_SPACE, "no enough buffer tail space (dropped)")
51 
52 
53 typedef enum
54 {
55 #define _(sym,str) ESP_DECRYPT_ERROR_##sym,
57 #undef _
60 
61 static char *esp_decrypt_error_strings[] = {
62 #define _(sym,string) string,
64 #undef _
65 };
66 
67 typedef struct
68 {
75 
76 /* packet trace format function */
77 static u8 *
78 format_esp_decrypt_trace (u8 * s, va_list * args)
79 {
80  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
81  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
82  esp_decrypt_trace_t *t = va_arg (*args, esp_decrypt_trace_t *);
83 
84  s =
85  format (s,
86  "esp: crypto %U integrity %U pkt-seq %d sa-seq %u sa-seq-hi %u",
88  t->integ_alg, t->seq, t->sa_seq, t->sa_seq_hi);
89  return s;
90 }
91 
92 typedef struct
93 {
94  union
95  {
96  struct
97  {
102  };
104  };
105 
111 
113 
114 #define ESP_ENCRYPT_PD_F_FD_TRANSPORT (1 << 2)
115 
118  vlib_node_runtime_t * node, vlib_frame_t * from_frame,
119  int is_ip6, int is_tun)
120 {
121  ipsec_main_t *im = &ipsec_main;
122  u32 thread_index = vm->thread_index;
123  u16 buffer_data_size = vlib_buffer_get_default_data_size (vm);
124  u16 len;
125  ipsec_per_thread_data_t *ptd = vec_elt_at_index (im->ptd, thread_index);
126  u32 *from = vlib_frame_vector_args (from_frame);
127  u32 n, n_left = from_frame->n_vectors;
128  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
129  u16 nexts[VLIB_FRAME_SIZE], *next = nexts;
130  esp_decrypt_packet_data_t pkt_data[VLIB_FRAME_SIZE], *pd = pkt_data;
131  esp_decrypt_packet_data_t cpd = { };
132  u32 current_sa_index = ~0, current_sa_bytes = 0, current_sa_pkts = 0;
133  const u8 esp_sz = sizeof (esp_header_t);
134  ipsec_sa_t *sa0 = 0;
135 
136  vlib_get_buffers (vm, from, b, n_left);
139  clib_memset_u16 (nexts, -1, n_left);
140 
141  while (n_left > 0)
142  {
143  u8 *payload;
144 
145  if (n_left > 2)
146  {
147  u8 *p;
148  vlib_prefetch_buffer_header (b[2], LOAD);
149  p = vlib_buffer_get_current (b[1]);
153  }
154 
155  if (vlib_buffer_chain_linearize (vm, b[0]) != 1)
156  {
157  b[0]->error = node->errors[ESP_DECRYPT_ERROR_CHAINED_BUFFER];
158  next[0] = ESP_DECRYPT_NEXT_DROP;
159  goto next;
160  }
161 
162  if (vnet_buffer (b[0])->ipsec.sad_index != current_sa_index)
163  {
164  if (current_sa_pkts)
166  current_sa_index,
167  current_sa_pkts,
168  current_sa_bytes);
169  current_sa_bytes = current_sa_pkts = 0;
170 
171  current_sa_index = vnet_buffer (b[0])->ipsec.sad_index;
172  sa0 = pool_elt_at_index (im->sad, current_sa_index);
173  cpd.icv_sz = sa0->integ_icv_size;
174  cpd.iv_sz = sa0->crypto_iv_size;
175  cpd.flags = sa0->flags;
176  cpd.sa_index = current_sa_index;
177  }
178 
179  /* store packet data for next round for easier prefetch */
180  pd->sa_data = cpd.sa_data;
181  pd->current_data = b[0]->current_data;
182  pd->current_length = b[0]->current_length;
183  pd->hdr_sz = pd->current_data - vnet_buffer (b[0])->l3_hdr_offset;
184  payload = b[0]->data + pd->current_data;
185  pd->seq = clib_host_to_net_u32 (((esp_header_t *) payload)->seq);
186 
187  /* we need 4 extra bytes for HMAC calculation when ESN are used */
188  if (ipsec_sa_is_set_USE_ESN (sa0) && pd->icv_sz &&
189  (pd->current_data + pd->current_length + 4 > buffer_data_size))
190  {
191  b[0]->error = node->errors[ESP_DECRYPT_ERROR_NO_TAIL_SPACE];
192  next[0] = ESP_DECRYPT_NEXT_DROP;
193  goto next;
194  }
195 
196  /* anti-reply check */
197  if (ipsec_sa_anti_replay_check (sa0, pd->seq))
198  {
199  b[0]->error = node->errors[ESP_DECRYPT_ERROR_REPLAY];
200  next[0] = ESP_DECRYPT_NEXT_DROP;
201  goto next;
202  }
203 
204  if (pd->current_length < cpd.icv_sz + esp_sz + cpd.iv_sz)
205  {
206  b[0]->error = node->errors[ESP_DECRYPT_ERROR_RUNT];
207  next[0] = ESP_DECRYPT_NEXT_DROP;
208  goto next;
209  }
210 
211  len = pd->current_length - cpd.icv_sz;
212  current_sa_pkts += 1;
213  current_sa_bytes += pd->current_length;
214 
216  {
217  vnet_crypto_op_t *op;
219 
220  vnet_crypto_op_init (op, sa0->integ_op_id);
221  op->key_index = sa0->integ_key_index;
222  op->src = payload;
224  op->user_data = b - bufs;
225  op->digest = payload + len;
226  op->digest_len = cpd.icv_sz;
227  op->len = len;
228  if (ipsec_sa_is_set_USE_ESN (sa0))
229  {
230  /* shift ICV by 4 bytes to insert ESN */
231  u32 seq_hi = clib_host_to_net_u32 (sa0->seq_hi);
232  u8 tmp[ESP_MAX_ICV_SIZE], sz = sizeof (sa0->seq_hi);
233  clib_memcpy_fast (tmp, payload + len, ESP_MAX_ICV_SIZE);
234  clib_memcpy_fast (payload + len, &seq_hi, sz);
235  clib_memcpy_fast (payload + len + sz, tmp, ESP_MAX_ICV_SIZE);
236  op->len += sz;
237  op->digest += sz;
238  }
239  }
240 
241  payload += esp_sz;
242  len -= esp_sz;
243 
245  {
246  vnet_crypto_op_t *op;
249  op->key_index = sa0->crypto_key_index;
250  op->iv = payload;
251 
252  if (ipsec_sa_is_set_IS_AEAD (sa0))
253  {
254  esp_header_t *esp0;
255  esp_aead_t *aad;
256  u8 *scratch;
257 
258  /*
259  * construct the AAD and the nonce (Salt || IV) in a scratch
260  * space in front of the IP header.
261  */
262  scratch = payload - esp_sz;
263  esp0 = (esp_header_t *) (scratch);
264 
265  scratch -= (sizeof (*aad) + pd->hdr_sz);
266  op->aad = scratch;
267 
268  esp_aad_fill (op, esp0, sa0);
269 
270  /*
271  * we don't need to refer to the ESP header anymore so we
272  * can overwrite it with the salt and use the IV where it is
273  * to form the nonce = (Salt + IV)
274  */
275  op->iv -= sizeof (sa0->salt);
276  clib_memcpy_fast (op->iv, &sa0->salt, sizeof (sa0->salt));
277 
278  op->tag = payload + len;
279  op->tag_len = 16;
280  }
281  op->src = op->dst = payload += cpd.iv_sz;
282  op->len = len - cpd.iv_sz;
283  op->user_data = b - bufs;
284  }
285 
286  /* next */
287  next:
288  n_left -= 1;
289  next += 1;
290  pd += 1;
291  b += 1;
292  }
293 
295  current_sa_index, current_sa_pkts,
296  current_sa_bytes);
297 
298  if ((n = vec_len (ptd->integ_ops)))
299  {
300  vnet_crypto_op_t *op = ptd->integ_ops;
301  n -= vnet_crypto_process_ops (vm, op, n);
302  while (n)
303  {
304  ASSERT (op - ptd->integ_ops < vec_len (ptd->integ_ops));
305  if (op->status != VNET_CRYPTO_OP_STATUS_COMPLETED)
306  {
307  u32 err, bi = op->user_data;
308  if (op->status == VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC)
309  err = ESP_DECRYPT_ERROR_INTEG_ERROR;
310  else
311  err = ESP_DECRYPT_ERROR_CRYPTO_ENGINE_ERROR;
312  bufs[bi]->error = node->errors[err];
313  nexts[bi] = ESP_DECRYPT_NEXT_DROP;
314  n--;
315  }
316  op++;
317  }
318  }
319  if ((n = vec_len (ptd->crypto_ops)))
320  {
321  vnet_crypto_op_t *op = ptd->crypto_ops;
322  n -= vnet_crypto_process_ops (vm, op, n);
323  while (n)
324  {
325  ASSERT (op - ptd->crypto_ops < vec_len (ptd->crypto_ops));
326  if (op->status != VNET_CRYPTO_OP_STATUS_COMPLETED)
327  {
328  u32 err, bi;
329 
330  bi = op->user_data;
331 
332  if (op->status == VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC)
333  err = ESP_DECRYPT_ERROR_DECRYPTION_FAILED;
334  else
335  err = ESP_DECRYPT_ERROR_CRYPTO_ENGINE_ERROR;
336 
337  bufs[bi]->error = node->errors[err];
338  nexts[bi] = ESP_DECRYPT_NEXT_DROP;
339  n--;
340  }
341  op++;
342  }
343  }
344 
345  /* Post decryption ronud - adjust packet data start and length and next
346  node */
347 
348  n_left = from_frame->n_vectors;
349  next = nexts;
350  pd = pkt_data;
351  b = bufs;
352 
353  while (n_left)
354  {
355  const u8 tun_flags = IPSEC_SA_FLAG_IS_TUNNEL |
356  IPSEC_SA_FLAG_IS_TUNNEL_V6;
357 
358  if (n_left >= 2)
359  {
360  void *data = b[1]->data + pd[1].current_data;
361 
362  /* buffer metadata */
363  vlib_prefetch_buffer_header (b[1], LOAD);
364 
365  /* esp_footer_t */
366  CLIB_PREFETCH (data + pd[1].current_length - pd[1].icv_sz - 2,
367  CLIB_CACHE_LINE_BYTES, LOAD);
368 
369  /* packet headers */
371  CLIB_CACHE_LINE_BYTES * 2, LOAD);
372  }
373 
374  if (next[0] < ESP_DECRYPT_N_NEXT)
375  goto trace;
376 
377  sa0 = vec_elt_at_index (im->sad, pd->sa_index);
378 
379  /*
380  * redo the anti-reply check
381  * in this frame say we have sequence numbers, s, s+1, s+1, s+1
382  * and s and s+1 are in the window. When we did the anti-replay
383  * check above we did so against the state of the window (W),
384  * after packet s-1. So each of the packets in the sequence will be
385  * accepted.
386  * This time s will be cheked against Ws-1, s+1 chceked against Ws
387  * (i.e. the window state is updated/advnaced)
388  * so this time the successive s+! packet will be dropped.
389  * This is a consequence of batching the decrypts. If the
390  * check-dcrypt-advance process was done for each packet it would
391  * be fine. But we batch the decrypts because it's much more efficient
392  * to do so in SW and if we offload to HW and the process is async.
393  *
394  * You're probably thinking, but this means an attacker can send the
395  * above sequence and cause VPP to perform decrpyts that will fail,
396  * and that's true. But if the attacker can determine s (a valid
397  * sequence number in the window) which is non-trivial, it can generate
398  * a sequence s, s+1, s+2, s+3, ... s+n and nothing will prevent any
399  * implementation, sequential or batching, from decrypting these.
400  */
401  if (ipsec_sa_anti_replay_check (sa0, pd->seq))
402  {
403  b[0]->error = node->errors[ESP_DECRYPT_ERROR_REPLAY];
404  next[0] = ESP_DECRYPT_NEXT_DROP;
405  goto trace;
406  }
407 
409 
410  esp_footer_t *f = (esp_footer_t *) (b[0]->data + pd->current_data +
411  pd->current_length - sizeof (*f) -
412  pd->icv_sz);
413  u16 adv = pd->iv_sz + esp_sz;
414  u16 tail = sizeof (esp_footer_t) + f->pad_length + pd->icv_sz;
415 
416  if ((pd->flags & tun_flags) == 0 && !is_tun) /* transport mode */
417  {
418  u8 udp_sz = (is_ip6 == 0 && pd->flags & IPSEC_SA_FLAG_UDP_ENCAP) ?
419  sizeof (udp_header_t) : 0;
420  u16 ip_hdr_sz = pd->hdr_sz - udp_sz;
421  u8 *old_ip = b[0]->data + pd->current_data - ip_hdr_sz - udp_sz;
422  u8 *ip = old_ip + adv + udp_sz;
423 
424  if (is_ip6 && ip_hdr_sz > 64)
425  memmove (ip, old_ip, ip_hdr_sz);
426  else
427  clib_memcpy_le64 (ip, old_ip, ip_hdr_sz);
428 
429  b[0]->current_data = pd->current_data + adv - ip_hdr_sz;
430  b[0]->current_length = pd->current_length + ip_hdr_sz - tail - adv;
431 
432  if (is_ip6)
433  {
434  ip6_header_t *ip6 = (ip6_header_t *) ip;
435  u16 len = clib_net_to_host_u16 (ip6->payload_length);
436  len -= adv + tail;
437  ip6->payload_length = clib_host_to_net_u16 (len);
438  ip6->protocol = f->next_header;
439  next[0] = ESP_DECRYPT_NEXT_IP6_INPUT;
440  }
441  else
442  {
443  ip4_header_t *ip4 = (ip4_header_t *) ip;
444  ip_csum_t sum = ip4->checksum;
445  u16 len = clib_net_to_host_u16 (ip4->length);
446  len = clib_host_to_net_u16 (len - adv - tail - udp_sz);
447  sum = ip_csum_update (sum, ip4->protocol, f->next_header,
449  sum = ip_csum_update (sum, ip4->length, len,
450  ip4_header_t, length);
451  ip4->checksum = ip_csum_fold (sum);
452  ip4->protocol = f->next_header;
453  ip4->length = len;
454  next[0] = ESP_DECRYPT_NEXT_IP4_INPUT;
455  }
456  }
457  else
458  {
459  if (PREDICT_TRUE (f->next_header == IP_PROTOCOL_IP_IN_IP))
460  {
461  next[0] = ESP_DECRYPT_NEXT_IP4_INPUT;
462  b[0]->current_data = pd->current_data + adv;
463  b[0]->current_length = pd->current_length - adv - tail;
464  }
465  else if (f->next_header == IP_PROTOCOL_IPV6)
466  {
467  next[0] = ESP_DECRYPT_NEXT_IP6_INPUT;
468  b[0]->current_data = pd->current_data + adv;
469  b[0]->current_length = pd->current_length - adv - tail;
470  }
471  else
472  {
473  next[0] = ESP_DECRYPT_NEXT_DROP;
474  b[0]->error = node->errors[ESP_DECRYPT_ERROR_DECRYPTION_FAILED];
475  goto trace;
476  }
477  if (is_tun)
478  {
479  if (ipsec_sa_is_set_IS_PROTECT (sa0))
480  {
481  /*
482  * Check that the reveal IP header matches that
483  * of the tunnel we are protecting
484  */
485  const ipsec_tun_protect_t *itp;
486 
487  itp =
489  ipsec.protect_index);
490  if (PREDICT_TRUE (f->next_header == IP_PROTOCOL_IP_IN_IP))
491  {
492  const ip4_header_t *ip4;
493 
494  ip4 = vlib_buffer_get_current (b[0]);
495 
497  &ip4->dst_address) ||
499  &ip4->src_address))
500  next[0] = ESP_DECRYPT_NEXT_DROP;
501 
502  }
503  else if (f->next_header == IP_PROTOCOL_IPV6)
504  {
505  const ip6_header_t *ip6;
506 
507  ip6 = vlib_buffer_get_current (b[0]);
508 
510  &ip6->dst_address) ||
512  &ip6->src_address))
513  next[0] = ESP_DECRYPT_NEXT_DROP;
514  }
515  }
516  }
517  }
518 
519  trace:
520  if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
521  {
523  tr = vlib_add_trace (vm, node, b[0], sizeof (*tr));
524  sa0 = pool_elt_at_index (im->sad,
525  vnet_buffer (b[0])->ipsec.sad_index);
526  tr->crypto_alg = sa0->crypto_alg;
527  tr->integ_alg = sa0->integ_alg;
528  tr->seq = pd->seq;
529  tr->sa_seq = sa0->last_seq;
530  tr->sa_seq_hi = sa0->seq_hi;
531  }
532 
533  /* next */
534  n_left -= 1;
535  next += 1;
536  pd += 1;
537  b += 1;
538  }
539 
540  n_left = from_frame->n_vectors;
542  ESP_DECRYPT_ERROR_RX_PKTS, n_left);
543 
544  vlib_buffer_enqueue_to_next (vm, node, from, nexts, n_left);
545 
546  b = bufs;
547  return n_left;
548 }
549 
550 VLIB_NODE_FN (esp4_decrypt_node) (vlib_main_t * vm,
551  vlib_node_runtime_t * node,
552  vlib_frame_t * from_frame)
553 {
554  return esp_decrypt_inline (vm, node, from_frame, 0, 0);
555 }
556 
557 VLIB_NODE_FN (esp4_decrypt_tun_node) (vlib_main_t * vm,
558  vlib_node_runtime_t * node,
559  vlib_frame_t * from_frame)
560 {
561  return esp_decrypt_inline (vm, node, from_frame, 0, 1);
562 }
563 
564 VLIB_NODE_FN (esp6_decrypt_node) (vlib_main_t * vm,
565  vlib_node_runtime_t * node,
566  vlib_frame_t * from_frame)
567 {
568  return esp_decrypt_inline (vm, node, from_frame, 1, 0);
569 }
570 
571 VLIB_NODE_FN (esp6_decrypt_tun_node) (vlib_main_t * vm,
572  vlib_node_runtime_t * node,
573  vlib_frame_t * from_frame)
574 {
575  return esp_decrypt_inline (vm, node, from_frame, 1, 1);
576 }
577 
578 /* *INDENT-OFF* */
579 VLIB_REGISTER_NODE (esp4_decrypt_node) = {
580  .name = "esp4-decrypt",
581  .vector_size = sizeof (u32),
582  .format_trace = format_esp_decrypt_trace,
584 
585  .n_errors = ARRAY_LEN(esp_decrypt_error_strings),
586  .error_strings = esp_decrypt_error_strings,
587 
588  .n_next_nodes = ESP_DECRYPT_N_NEXT,
589  .next_nodes = {
590 #define _(s,n) [ESP_DECRYPT_NEXT_##s] = n,
592 #undef _
593  },
594 };
595 
596 VLIB_REGISTER_NODE (esp6_decrypt_node) = {
597  .name = "esp6-decrypt",
598  .vector_size = sizeof (u32),
599  .format_trace = format_esp_decrypt_trace,
601 
602  .n_errors = ARRAY_LEN(esp_decrypt_error_strings),
603  .error_strings = esp_decrypt_error_strings,
604 
605  .n_next_nodes = ESP_DECRYPT_N_NEXT,
606  .next_nodes = {
607 #define _(s,n) [ESP_DECRYPT_NEXT_##s] = n,
609 #undef _
610  },
611 };
612 
613 VLIB_REGISTER_NODE (esp4_decrypt_tun_node) = {
614  .name = "esp4-decrypt-tun",
615  .vector_size = sizeof (u32),
616  .format_trace = format_esp_decrypt_trace,
618 
619  .n_errors = ARRAY_LEN(esp_decrypt_error_strings),
620  .error_strings = esp_decrypt_error_strings,
621 
622  .n_next_nodes = ESP_DECRYPT_N_NEXT,
623  .next_nodes = {
624 #define _(s,n) [ESP_DECRYPT_NEXT_##s] = n,
626 #undef _
627  },
628 };
629 
630 VLIB_REGISTER_NODE (esp6_decrypt_tun_node) = {
631  .name = "esp6-decrypt-tun",
632  .vector_size = sizeof (u32),
633  .format_trace = format_esp_decrypt_trace,
635 
636  .n_errors = ARRAY_LEN(esp_decrypt_error_strings),
637  .error_strings = esp_decrypt_error_strings,
638 
639  .n_next_nodes = ESP_DECRYPT_N_NEXT,
640  .next_nodes = {
641 #define _(s,n) [ESP_DECRYPT_NEXT_##s] = n,
643 #undef _
644  },
645 };
646 /* *INDENT-ON* */
647 
648 /*
649  * fd.io coding-style-patch-verification: ON
650  *
651  * Local Variables:
652  * eval: (c-set-style "gnu")
653  * End:
654  */
u32 vnet_crypto_process_ops(vlib_main_t *vm, vnet_crypto_op_t ops[], u32 n_ops)
Definition: crypto.c:46
u8 * format_ipsec_integ_alg(u8 *s, va_list *args)
Definition: ipsec_format.c:110
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
Definition: vlib_api_cli.c:889
u32 flags
Definition: vhost_user.h:141
static u8 * format_esp_decrypt_trace(u8 *s, va_list *args)
Definition: esp_decrypt.c:78
#define CLIB_UNUSED(x)
Definition: clib.h:83
ipsec_per_thread_data_t * ptd
Definition: ipsec.h:169
vnet_crypto_op_t * integ_ops
Definition: ipsec.h:89
static char * esp_decrypt_error_strings[]
Definition: esp_decrypt.c:61
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:220
ip4_address_t src_address
Definition: ip4_packet.h:170
#define PREDICT_TRUE(x)
Definition: clib.h:113
ipsec_integ_alg_t
Definition: ipsec_sa.h:58
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:110
unsigned long u64
Definition: types.h:89
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
#define vec_add2_aligned(V, P, N, A)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:572
ipsec_integ_alg_t integ_alg
Definition: ipsec_sa.h:150
u32 thread_index
Definition: main.h:218
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
vnet_crypto_op_t * crypto_ops
Definition: ipsec.h:88
ipsec_crypto_alg_t crypto_alg
Definition: esp_decrypt.c:72
AES GCM Additional Authentication data.
Definition: esp.h:64
uword ip_csum_t
Definition: ip_packet.h:219
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u8 data[128]
Definition: ipsec.api:251
#define VLIB_NODE_FN(node)
Definition: node.h:202
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:470
vnet_crypto_op_id_t integ_op_id
Definition: ipsec_sa.h:129
ip6_address_t src_address
Definition: ip6_packet.h:383
esp_decrypt_next_t
Definition: esp_decrypt.c:33
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u32 seq_hi
Definition: ipsec_sa.h:119
vnet_crypto_key_index_t crypto_key_index
Definition: ipsec_sa.h:125
ip46_address_t src
Definition: ipsec_tun.h:28
ipsec_main_t ipsec_main
Definition: ipsec.c:28
#define always_inline
Definition: clib.h:99
ip4_address_t dst_address
Definition: ip4_packet.h:170
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:203
static_always_inline void vnet_crypto_op_init(vnet_crypto_op_t *op, vnet_crypto_op_id_t type)
Definition: crypto.h:221
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
ipsec_ep_t itp_tun
Definition: ipsec_tun.h:48
u8 * format_ipsec_crypto_alg(u8 *s, va_list *args)
Definition: ipsec_format.c:78
unsigned int u32
Definition: types.h:88
#define foreach_esp_decrypt_error
Definition: esp_decrypt.c:41
ipsec_sa_flags_t flags
Definition: ipsec_sa.h:112
#define VLIB_FRAME_SIZE
Definition: node.h:378
vl_api_fib_path_type_t type
Definition: fib_types.api:123
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
u32 last_seq
Definition: ipsec_sa.h:120
static u32 vlib_buffer_chain_linearize(vlib_main_t *vm, vlib_buffer_t *b)
#define ESP_MAX_ICV_SIZE
Definition: esp.h:78
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
static_always_inline int ip46_address_is_equal_v6(const ip46_address_t *ip46, const ip6_address_t *ip6)
Definition: ip6_packet.h:106
static void esp_aad_fill(vnet_crypto_op_t *op, const esp_header_t *esp, const ipsec_sa_t *sa)
Definition: esp.h:138
uword user_data
Definition: crypto.h:143
vl_api_ip_proto_t protocol
Definition: punt.api:39
u32 salt
Definition: ipsec_sa.h:163
static void ipsec_sa_anti_replay_advance(ipsec_sa_t *sa, u32 seq)
Definition: ipsec_sa.h:379
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
#define PREDICT_FALSE(x)
Definition: clib.h:112
u32 node_index
Node index.
Definition: node.h:496
#define VNET_CRYPTO_OP_FLAG_HMAC_CHECK
Definition: crypto.h:132
STATIC_ASSERT_SIZEOF(esp_decrypt_packet_data_t, 3 *sizeof(u64))
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1150
u8 len
Definition: ip_types.api:90
static_always_inline u32 vlib_buffer_get_default_data_size(vlib_main_t *vm)
Definition: buffer_funcs.h:96
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u16 n_vectors
Definition: node.h:397
static uword esp_decrypt_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip6, int is_tun)
Definition: esp_decrypt.c:117
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
vlib_main_t * vm
Definition: buffer.c:323
static_always_inline void vlib_buffer_enqueue_to_next(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u16 *nexts, uword count)
Definition: buffer_node.h:332
u8 data[]
Packet data.
Definition: buffer.h:181
enum ipsec_sad_flags_t_ ipsec_sa_flags_t
#define ARRAY_LEN(x)
Definition: clib.h:63
ip46_address_t dst
Definition: ipsec_tun.h:29
vlib_combined_counter_main_t ipsec_sa_counters
SA packet & bytes counters.
Definition: ipsec_sa.c:27
#define ASSERT(truth)
esp_decrypt_error_t
Definition: esp_decrypt.c:53
ipsec_sa_t * sad
Definition: ipsec.h:97
static ipsec_tun_protect_t * ipsec_tun_protect_get(u32 index)
Definition: ipsec_tun.h:103
ipsec_sa_flags_t flags
Definition: esp_decrypt.c:100
static int ipsec_sa_anti_replay_check(ipsec_sa_t *sa, u32 seq)
Definition: ipsec_sa.h:252
vnet_crypto_key_index_t integ_key_index
Definition: ipsec_sa.h:126
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
static_always_inline void clib_memset_u16(void *p, u16 val, uword count)
Definition: string.h:378
static_always_inline void clib_memcpy_le64(u8 *dst, u8 *src, u8 len)
Definition: string.h:283
u16 payload_length
Definition: ip6_packet.h:374
vl_api_address_t ip
Definition: l2.api:489
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
ipsec_crypto_alg_t
Definition: ipsec_sa.h:36
#define ip_csum_update(sum, old, new, type, field)
Definition: ip_packet.h:269
vnet_crypto_op_id_t crypto_enc_op_id
Definition: ipsec_sa.h:127
vnet_crypto_op_status_t status
Definition: crypto.h:129
#define vnet_buffer(b)
Definition: buffer.h:365
static_always_inline int ip46_address_is_equal_v4(const ip46_address_t *ip46, const ip4_address_t *ip4)
Definition: ip6_packet.h:99
#define foreach_esp_decrypt_next
Definition: esp_decrypt.c:27
ipsec_crypto_alg_t crypto_alg
Definition: ipsec_sa.h:146
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
Definition: buffer_funcs.h:244
u8 crypto_iv_size
Definition: ipsec_sa.h:114
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
vnet_crypto_op_id_t crypto_dec_op_id
Definition: ipsec_sa.h:128
u8 integ_icv_size
Definition: ipsec_sa.h:116
static u16 ip_csum_fold(ip_csum_t c)
Definition: ip_packet.h:275
ipsec_integ_alg_t integ_alg
Definition: esp_decrypt.c:73
ip6_address_t dst_address
Definition: ip6_packet.h:383
signed short i16
Definition: types.h:46