FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
crypto.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 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 
16 #include <stdbool.h>
17 #include <vlib/vlib.h>
18 #include <vnet/crypto/crypto.h>
19 
21 
23 crypto_set_op_status (vnet_crypto_op_t * ops[], u32 n_ops, int status)
24 {
25  while (n_ops--)
26  {
27  ops[0]->status = status;
28  ops++;
29  }
30 }
31 
36  vnet_crypto_op_t * ops[],
37  vnet_crypto_op_chunk_t * chunks,
38  u32 n_ops)
39 {
40  u32 rv = 0;
41  if (n_ops == 0)
42  return 0;
43 
44  if (chunks)
45  {
46 
47  if (cm->chained_ops_handlers[opt] == 0)
48  crypto_set_op_status (ops, n_ops,
49  VNET_CRYPTO_OP_STATUS_FAIL_NO_HANDLER);
50  else
51  rv = (cm->chained_ops_handlers[opt]) (vm, ops, chunks, n_ops);
52  }
53  else
54  {
55  if (cm->ops_handlers[opt] == 0)
56  crypto_set_op_status (ops, n_ops,
57  VNET_CRYPTO_OP_STATUS_FAIL_NO_HANDLER);
58  else
59  rv = (cm->ops_handlers[opt]) (vm, ops, n_ops);
60  }
61  return rv;
62 }
63 
66  vnet_crypto_op_chunk_t * chunks, u32 n_ops)
67 {
69  const int op_q_size = VLIB_FRAME_SIZE;
70  vnet_crypto_op_t *op_queue[op_q_size];
71  vnet_crypto_op_id_t opt, current_op_type = ~0;
72  u32 n_op_queue = 0;
73  u32 rv = 0, i;
74 
75  ASSERT (n_ops >= 1);
76 
77  for (i = 0; i < n_ops; i++)
78  {
79  opt = ops[i].op;
80 
81  if (current_op_type != opt || n_op_queue >= op_q_size)
82  {
83  rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
84  op_queue, chunks,
85  n_op_queue);
86  n_op_queue = 0;
87  current_op_type = opt;
88  }
89 
90  op_queue[n_op_queue++] = &ops[i];
91  }
92 
93  rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
94  op_queue, chunks, n_op_queue);
95  return rv;
96 }
97 
98 u32
100 {
101  return vnet_crypto_process_ops_inline (vm, ops, 0, n_ops);
102 }
103 
104 u32
106  vnet_crypto_op_chunk_t * chunks, u32 n_ops)
107 {
108  return vnet_crypto_process_ops_inline (vm, ops, chunks, n_ops);
109 }
110 
111 u32
113  char *desc)
114 {
117 
118  vec_add2 (cm->engines, p, 1);
119  p->name = name;
120  p->desc = desc;
121  p->priority = prio;
122 
123  hash_set_mem (cm->engine_index_by_name, p->name, p - cm->engines);
124 
125  return p - cm->engines;
126 }
127 
130  vnet_crypto_op_id_t id, u32 ei,
132 {
135 
136  if (oct == CRYPTO_OP_BOTH || oct == CRYPTO_OP_CHAINED)
137  {
138  if (ce->chained_ops_handlers[id])
139  {
142  }
143  }
144 
145  if (oct == CRYPTO_OP_BOTH || oct == CRYPTO_OP_SIMPLE)
146  {
147  if (ce->ops_handlers[id])
148  {
150  cm->ops_handlers[id] = ce->ops_handlers[id];
151  }
152  }
153 }
154 
155 int
156 vnet_crypto_set_handler2 (char *alg_name, char *engine,
158 {
159  uword *p;
162  int i;
163 
164  p = hash_get_mem (cm->alg_index_by_name, alg_name);
165  if (!p)
166  return -1;
167 
168  ad = vec_elt_at_index (cm->algs, p[0]);
169 
170  p = hash_get_mem (cm->engine_index_by_name, engine);
171  if (!p)
172  return -1;
173 
174  for (i = 0; i < VNET_CRYPTO_OP_N_TYPES; i++)
175  {
177  vnet_crypto_op_id_t id = ad->op_by_type[i];
178  if (id == 0)
179  continue;
180 
181  od = cm->opt_data + id;
182  crypto_set_active_engine (od, id, p[0], oct);
183  }
184 
185  return 0;
186 }
187 
188 int
190 {
192 
193  return (alg < vec_len (cm->ops_handlers) && NULL != cm->ops_handlers[alg]);
194 }
195 
196 void
201  cfn)
202 {
204  vnet_crypto_engine_t *ae, *e = vec_elt_at_index (cm->engines, engine_index);
205  vnet_crypto_op_data_t *otd = cm->opt_data + opt;
210 
211  if (fn)
212  {
213  e->ops_handlers[opt] = fn;
214  if (otd->active_engine_index_simple == ~0)
215  {
216  otd->active_engine_index_simple = engine_index;
217  cm->ops_handlers[opt] = fn;
218  }
219 
221  if (ae->priority < e->priority)
222  crypto_set_active_engine (otd, opt, engine_index, CRYPTO_OP_SIMPLE);
223  }
224 
225  if (cfn)
226  {
227  e->chained_ops_handlers[opt] = cfn;
228  if (otd->active_engine_index_chained == ~0)
229  {
230  otd->active_engine_index_chained = engine_index;
231  cm->chained_ops_handlers[opt] = cfn;
232  }
233 
235  if (ae->priority < e->priority)
236  crypto_set_active_engine (otd, opt, engine_index, CRYPTO_OP_CHAINED);
237  }
238 
239  return;
240 }
241 
242 void
246 {
247  vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, fn, 0);
248 }
249 
250 void
254  fn)
255 {
256  vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, 0, fn);
257 }
258 
259 void
264 {
265  vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, fn, cfn);
266 }
267 
268 void
271  vnet_crypto_frame_enqueue_t * enqueue_hdl,
272  vnet_crypto_frame_dequeue_t * dequeue_hdl)
273 {
275  vnet_crypto_engine_t *ae, *e = vec_elt_at_index (cm->engines, engine_index);
281 
282  /* both enqueue hdl and dequeue hdl should present */
283  if (!enqueue_hdl && !dequeue_hdl)
284  return;
285 
286  e->enqueue_handlers[opt] = enqueue_hdl;
287  e->dequeue_handlers[opt] = dequeue_hdl;
288  if (otd->active_engine_index_async == ~0)
289  {
290  otd->active_engine_index_async = engine_index;
291  cm->enqueue_handlers[opt] = enqueue_hdl;
292  cm->dequeue_handlers[opt] = dequeue_hdl;
293  }
294 
296  if (ae->priority < e->priority)
297  {
298  otd->active_engine_index_async = engine_index;
299  cm->enqueue_handlers[opt] = enqueue_hdl;
300  cm->dequeue_handlers[opt] = dequeue_hdl;
301  }
302 
303  return;
304 }
305 
306 void
308  vnet_crypto_key_handler_t * key_handler)
309 {
311  vnet_crypto_engine_t *e = vec_elt_at_index (cm->engines, engine_index);
312  e->key_op_handler = key_handler;
313  return;
314 }
315 
316 static int
318 {
319  switch (alg)
320  {
321  case VNET_CRYPTO_N_ALGS:
322  return 0;
324  return 1;
325 
326 #define _(n, s, l) \
327  case VNET_CRYPTO_ALG_##n: \
328  if ((l) == length) \
329  return 1; \
330  break;
332 #undef _
333  /* HMAC allows any key length */
334 #define _(n, s) \
335  case VNET_CRYPTO_ALG_HMAC_##n: \
336  return 1;
338 #undef _
339  }
340 
341  return 0;
342 }
343 
344 u32
346  u16 length)
347 {
348  u32 index;
350  vnet_crypto_engine_t *engine;
352 
353  if (!vnet_crypto_key_len_check (alg, length))
354  return ~0;
355 
356  pool_get_zero (cm->keys, key);
357  index = key - cm->keys;
359  key->alg = alg;
360  vec_validate_aligned (key->data, length - 1, CLIB_CACHE_LINE_BYTES);
361  clib_memcpy (key->data, data, length);
362  /* *INDENT-OFF* */
363  vec_foreach (engine, cm->engines)
364  if (engine->key_op_handler)
365  engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_ADD, index);
366  /* *INDENT-ON* */
367  return index;
368 }
369 
370 void
372 {
374  vnet_crypto_engine_t *engine;
376 
377  /* *INDENT-OFF* */
378  vec_foreach (engine, cm->engines)
379  if (engine->key_op_handler)
380  engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_DEL, index);
381  /* *INDENT-ON* */
382 
383  if (key->type == VNET_CRYPTO_KEY_TYPE_DATA)
384  {
385  clib_memset (key->data, 0, vec_len (key->data));
386  vec_free (key->data);
387  }
388  else if (key->type == VNET_CRYPTO_KEY_TYPE_LINK)
389  {
390  key->index_crypto = key->index_integ = 0;
391  }
392 
393  pool_put (cm->keys, key);
394 }
395 
398  vnet_crypto_alg_t integ_alg)
399 {
400 #define _(c, h, s, k ,d) \
401  if (crypto_alg == VNET_CRYPTO_ALG_##c && \
402  integ_alg == VNET_CRYPTO_ALG_HMAC_##h) \
403  return VNET_CRYPTO_ALG_##c##_##h##_TAG##d;
405 #undef _
406  return ~0;
407 }
408 
409 u32
411  vnet_crypto_key_index_t index_crypto,
412  vnet_crypto_key_index_t index_integ)
413 {
414  u32 index;
416  vnet_crypto_engine_t *engine;
417  vnet_crypto_key_t *key_crypto, *key_integ, *key;
418  vnet_crypto_async_alg_t linked_alg;
419 
420  key_crypto = pool_elt_at_index (cm->keys, index_crypto);
421  key_integ = pool_elt_at_index (cm->keys, index_integ);
422 
423  if (!key_crypto || !key_integ)
424  return ~0;
425 
426  linked_alg = vnet_crypto_link_algs (key_crypto->alg, key_integ->alg);
427  if (linked_alg == ~0)
428  return ~0;
429 
430  pool_get_zero (cm->keys, key);
431  index = key - cm->keys;
433  key->index_crypto = index_crypto;
434  key->index_integ = index_integ;
435  key->async_alg = linked_alg;
436 
437  /* *INDENT-OFF* */
438  vec_foreach (engine, cm->engines)
439  if (engine->key_op_handler)
440  engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_ADD, index);
441  /* *INDENT-ON* */
442 
443  return index;
444 }
445 
446 clib_error_t *
448 {
451  vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
453  u32 skip_master = vlib_num_workers () > 0, i;
454  u32 state_change = 0;
456 
457  if (is_enable && cm->async_refcnt > 0)
458  {
459  state_change = 1;
460  state = VLIB_NODE_STATE_POLLING;
461  }
462 
463  if (!is_enable && cm->async_refcnt == 0)
464  {
465  state_change = 1;
466  state = VLIB_NODE_STATE_DISABLED;
467  }
468 
469  if (state_change)
470  for (i = skip_master; i < tm->n_vlib_mains; i++)
471  vlib_node_set_state (vlib_mains[i], node->index, state);
472 
473  return 0;
474 }
475 
479 {
482 
483  if (ce->enqueue_handlers[id] && ce->dequeue_handlers[id])
484  {
485  od->active_engine_index_async = ei;
488  }
489 }
490 
491 int
492 vnet_crypto_set_async_handler2 (char *alg_name, char *engine)
493 {
494  uword *p;
497  int i;
498 
499  p = hash_get_mem (cm->async_alg_index_by_name, alg_name);
500  if (!p)
501  return -1;
502 
503  ad = vec_elt_at_index (cm->async_algs, p[0]);
504 
505  p = hash_get_mem (cm->engine_index_by_name, engine);
506  if (!p)
507  return -1;
508 
509  for (i = 0; i < VNET_CRYPTO_ASYNC_OP_N_TYPES; i++)
510  {
513  if (id == 0)
514  continue;
515 
516  od = cm->async_opt_data + id;
517  crypto_set_active_async_engine (od, id, p[0]);
518  }
519 
520  return 0;
521 }
522 
523 u32
525 {
528  vlib_node_t *cc, *pn;
529  uword index = vec_len (cm->next_nodes);
530 
531  pn = vlib_get_node_by_name (vm, (u8 *) post_node_name);
532  if (!pn)
533  return ~0;
534 
535  /* *INDENT-OFF* */
536  vec_foreach (cm->next_nodes, nn)
537  {
538  if (nn->node_idx == pn->index)
539  return nn->next_idx;
540  }
541  /* *INDENT-ON* */
542 
543  vec_validate (cm->next_nodes, index);
544  nn = vec_elt_at_index (cm->next_nodes, index);
545 
546  cc = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
547  nn->next_idx = vlib_node_add_named_next (vm, cc->index, post_node_name);
548  nn->node_idx = pn->index;
549 
550  return nn->next_idx;
551 }
552 
553 void
555 {
558  vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
560  u32 skip_master = vlib_num_workers () > 0, i;
561  u32 state_change = 0;
563 
564  if (is_enable && cm->async_refcnt == 0)
565  {
566  state_change = 1;
567  state = VLIB_NODE_STATE_POLLING;
568  }
569 
570  if (!is_enable && cm->async_refcnt == 1)
571  {
572  state_change = 1;
573  state = VLIB_NODE_STATE_DISABLED;
574  }
575 
576  if (state_change)
577  for (i = skip_master; i < tm->n_vlib_mains; i++)
578  vlib_node_set_state (vlib_mains[i], node->index, state);
579 
580  if (is_enable)
581  cm->async_refcnt += 1;
582  else if (cm->async_refcnt > 0)
583  cm->async_refcnt -= 1;
584 }
585 
586 int
588 {
590 
591  return (op < vec_len (cm->enqueue_handlers) &&
592  NULL != cm->enqueue_handlers[op]);
593 }
594 
595 static void
597  vnet_crypto_op_id_t did, char *name, u8 is_aead)
598 {
599  vnet_crypto_op_type_t eopt, dopt;
601 
602  cm->algs[alg].name = name;
603  cm->opt_data[eid].alg = cm->opt_data[did].alg = alg;
605  cm->opt_data[did].active_engine_index_simple = ~0;
608  if (is_aead)
609  {
610  eopt = VNET_CRYPTO_OP_TYPE_AEAD_ENCRYPT;
611  dopt = VNET_CRYPTO_OP_TYPE_AEAD_DECRYPT;
612  }
613  else
614  {
615  eopt = VNET_CRYPTO_OP_TYPE_ENCRYPT;
616  dopt = VNET_CRYPTO_OP_TYPE_DECRYPT;
617  }
618  cm->opt_data[eid].type = eopt;
619  cm->opt_data[did].type = dopt;
620  cm->algs[alg].op_by_type[eopt] = eid;
621  cm->algs[alg].op_by_type[dopt] = did;
622  hash_set_mem (cm->alg_index_by_name, name, alg);
623 }
624 
625 static void
627  vnet_crypto_op_id_t id, char *name)
628 {
630  cm->algs[alg].name = name;
631  cm->algs[alg].op_by_type[VNET_CRYPTO_OP_TYPE_HMAC] = id;
632  cm->opt_data[id].alg = alg;
635  cm->opt_data[id].type = VNET_CRYPTO_OP_TYPE_HMAC;
636  hash_set_mem (cm->alg_index_by_name, name, alg);
637 }
638 
639 static void
642  vnet_crypto_async_op_id_t did, char *name)
643 {
645 
646  cm->async_algs[alg].name = name;
647  cm->async_algs[alg].op_by_type[VNET_CRYPTO_ASYNC_OP_TYPE_ENCRYPT] = eid;
648  cm->async_algs[alg].op_by_type[VNET_CRYPTO_ASYNC_OP_TYPE_DECRYPT] = did;
649  cm->async_opt_data[eid].type = VNET_CRYPTO_ASYNC_OP_TYPE_ENCRYPT;
650  cm->async_opt_data[eid].alg = alg;
653  cm->async_opt_data[did].type = VNET_CRYPTO_ASYNC_OP_TYPE_DECRYPT;
654  cm->async_opt_data[did].alg = alg;
657  hash_set_mem (cm->async_alg_index_by_name, name, alg);
658 }
659 
660 clib_error_t *
662 {
665  vnet_crypto_thread_t *ct = 0;
666  cm->engine_index_by_name = hash_create_string ( /* size */ 0,
667  sizeof (uword));
668  cm->alg_index_by_name = hash_create_string (0, sizeof (uword));
671  vec_foreach (ct, cm->threads)
676 
677 #define _(n, s, l) \
678  vnet_crypto_init_cipher_data (VNET_CRYPTO_ALG_##n, \
679  VNET_CRYPTO_OP_##n##_ENC, \
680  VNET_CRYPTO_OP_##n##_DEC, s, 0);
682 #undef _
683 #define _(n, s, l) \
684  vnet_crypto_init_cipher_data (VNET_CRYPTO_ALG_##n, \
685  VNET_CRYPTO_OP_##n##_ENC, \
686  VNET_CRYPTO_OP_##n##_DEC, s, 1);
688 #undef _
689 #define _(n, s) \
690  vnet_crypto_init_hmac_data (VNET_CRYPTO_ALG_HMAC_##n, \
691  VNET_CRYPTO_OP_##n##_HMAC, "hmac-" s);
693 #undef _
694 #define _(n, s, k, t, a) \
695  vnet_crypto_init_async_data (VNET_CRYPTO_ALG_##n##_TAG##t##_AAD##a, \
696  VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_ENC, \
697  VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_DEC, \
698  s);
700 #undef _
701 #define _(c, h, s, k ,d) \
702  vnet_crypto_init_async_data (VNET_CRYPTO_ALG_##c##_##h##_TAG##d, \
703  VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC, \
704  VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC, \
705  s);
707 #undef _
708  return 0;
709 }
710 
712 
713 /*
714  * fd.io coding-style-patch-verification: ON
715  *
716  * Local Variables:
717  * eval: (c-set-style "gnu")
718  * End:
719  */
u32 vnet_crypto_process_ops(vlib_main_t *vm, vnet_crypto_op_t ops[], u32 n_ops)
Definition: crypto.c:99
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:507
static void vnet_crypto_init_async_data(vnet_crypto_async_alg_t alg, vnet_crypto_async_op_id_t eid, vnet_crypto_async_op_id_t did, char *name)
Definition: crypto.c:640
int() vnet_crypto_frame_enqueue_t(vlib_main_t *vm, vnet_crypto_async_frame_t *frame)
async crypto function handlers
Definition: crypto.h:357
uword * async_alg_index_by_name
Definition: crypto.h:427
vnet_crypto_engine_t * engines
Definition: crypto.h:423
vnet_crypto_thread_t * threads
Definition: crypto.h:415
uword * alg_index_by_name
Definition: crypto.h:426
#define foreach_crypto_link_async_alg
Definition: crypto.h:84
vnet_crypto_async_op_id_t op_by_type[VNET_CRYPTO_ASYNC_OP_N_TYPES]
Definition: crypto.h:296
static_always_inline void crypto_set_active_engine(vnet_crypto_op_data_t *od, vnet_crypto_op_id_t id, u32 ei, crypto_op_class_type_t oct)
Definition: crypto.c:129
static_always_inline void crypto_set_op_status(vnet_crypto_op_t *ops[], u32 n_ops, int status)
Definition: crypto.c:23
#define VNET_CRYPTO_KEY_TYPE_LINK
Definition: crypto.h:189
vnet_crypto_op_data_t opt_data[VNET_CRYPTO_N_OP_IDS]
Definition: crypto.h:421
u32() vnet_crypto_chained_ops_handler_t(vlib_main_t *vm, vnet_crypto_op_t *ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops)
Definition: crypto.h:344
int vnet_crypto_set_async_handler2(char *alg_name, char *engine)
Definition: crypto.c:492
#define pool_get_zero(P, E)
Allocate an object E from a pool P and zero it.
Definition: pool.h:255
static_always_inline void crypto_set_active_async_engine(vnet_crypto_async_op_data_t *od, vnet_crypto_async_op_id_t id, u32 ei)
Definition: crypto.c:477
vnet_crypto_alg_data_t * algs
Definition: crypto.h:414
vnet_crypto_frame_enqueue_t ** enqueue_handlers
Definition: crypto.h:418
static uword vlib_node_add_named_next(vlib_main_t *vm, uword node, char *name)
Definition: node_funcs.h:1104
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
u32 index
Definition: node.h:282
vnet_crypto_op_id_t op_by_type[VNET_CRYPTO_OP_N_TYPES]
Definition: crypto.h:218
vnet_crypto_async_alg_data_t * async_algs
Definition: crypto.h:428
vnet_crypto_async_op_type_t type
Definition: crypto.h:288
void vnet_crypto_request_async_mode(int is_enable)
Definition: crypto.c:554
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:628
#define hash_set_mem(h, key, value)
Definition: hash.h:275
vnet_crypto_async_alg_t vnet_crypto_link_algs(vnet_crypto_alg_t crypto_alg, vnet_crypto_alg_t integ_alg)
Definition: crypto.c:397
vnet_crypto_frame_dequeue_t * dequeue_handlers[VNET_CRYPTO_ASYNC_OP_N_IDS]
Definition: crypto.h:403
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:518
static void vnet_crypto_init_hmac_data(vnet_crypto_alg_t alg, vnet_crypto_op_id_t id, char *name)
Definition: crypto.c:626
vlib_main_t ** vlib_mains
Definition: buffer.c:332
unsigned char u8
Definition: types.h:56
u8 id[64]
Definition: dhcp.api:160
#define clib_memcpy(d, s, n)
Definition: string.h:180
int vnet_crypto_is_set_handler(vnet_crypto_alg_t alg)
Definition: crypto.c:189
void vnet_crypto_register_ops_handlers(vlib_main_t *vm, u32 engine_index, vnet_crypto_op_id_t opt, vnet_crypto_ops_handler_t *fn, vnet_crypto_chained_ops_handler_t *cfn)
Definition: crypto.c:260
#define clib_bitmap_validate(v, n_bits)
Definition: bitmap.h:115
vnet_crypto_op_type_t
Definition: crypto.h:55
void vnet_crypto_register_async_handler(vlib_main_t *vm, u32 engine_index, vnet_crypto_async_op_id_t opt, vnet_crypto_frame_enqueue_t *enqueue_hdl, vnet_crypto_frame_dequeue_t *dequeue_hdl)
Definition: crypto.c:269
void vnet_crypto_register_key_handler(vlib_main_t *vm, u32 engine_index, vnet_crypto_key_handler_t *key_handler)
Definition: crypto.c:307
#define static_always_inline
Definition: clib.h:106
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
#define pool_alloc_aligned(P, N, A)
Allocate N more free elements to pool (general version).
Definition: pool.h:338
#define foreach_crypto_aead_alg
Definition: crypto.h:35
int vnet_crypto_set_handler2(char *alg_name, char *engine, crypto_op_class_type_t oct)
Definition: crypto.c:156
vnet_crypto_async_frame_t *() vnet_crypto_frame_dequeue_t(vlib_main_t *vm)
Definition: crypto.h:360
u32 active_engine_index_chained
Definition: crypto.h:283
vnet_crypto_alg_t alg
Definition: crypto.h:281
#define VNET_CRYPTO_KEY_TYPE_DATA
Definition: crypto.h:188
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
typedef eid
Definition: lisp_types.api:59
#define foreach_crypto_hmac_alg
Definition: crypto.h:40
unsigned int u32
Definition: types.h:88
#define VLIB_FRAME_SIZE
Definition: node.h:380
u32 vnet_crypto_key_add(vlib_main_t *vm, vnet_crypto_alg_t alg, u8 *data, u16 length)
Definition: crypto.c:345
vnet_crypto_op_id_t op
Definition: crypto.h:232
vnet_crypto_alg_t
Definition: crypto.h:121
vnet_crypto_chained_ops_handler_t ** chained_ops_handlers
Definition: crypto.h:417
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
clib_error_t * crypto_dispatch_enable_disable(int is_enable)
Definition: crypto.c:447
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
void() vnet_crypto_key_handler_t(vlib_main_t *vm, vnet_crypto_key_op_t kop, vnet_crypto_key_index_t idx)
Definition: crypto.h:352
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
vnet_crypto_key_handler_t * key_op_handler
Definition: crypto.h:398
vnet_crypto_async_next_node_t * next_nodes
Definition: crypto.h:430
unsigned short u16
Definition: types.h:57
void vnet_crypto_key_del(vlib_main_t *vm, vnet_crypto_key_index_t index)
Definition: crypto.c:371
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
u32 vnet_crypto_register_post_node(vlib_main_t *vm, char *post_node_name)
async crypto register functions
Definition: crypto.c:524
void vnet_crypto_register_ops_handler(vlib_main_t *vm, u32 engine_index, vnet_crypto_op_id_t opt, vnet_crypto_ops_handler_t *fn)
Definition: crypto.c:243
u32 active_engine_index_simple
Definition: crypto.h:282
vnet_crypto_alg_t alg
Definition: crypto.h:179
vlib_main_t * vm
Definition: in2out_ed.c:1599
vnet_crypto_async_frame_t * frame_pool
Definition: crypto.h:337
vnet_crypto_async_alg_t async_alg
Definition: crypto.h:185
static_always_inline u32 vnet_crypto_process_ops_inline(vlib_main_t *vm, vnet_crypto_op_t ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops)
Definition: crypto.c:65
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
vnet_crypto_frame_dequeue_t ** dequeue_handlers
Definition: crypto.h:419
static int vnet_crypto_key_len_check(vnet_crypto_alg_t alg, u16 length)
Definition: crypto.c:317
vnet_crypto_chained_ops_handler_t * chained_ops_handlers[VNET_CRYPTO_N_OP_IDS]
Definition: crypto.h:401
u32() vnet_crypto_ops_handler_t(vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops)
Definition: crypto.h:349
string name[64]
Definition: ip.api:44
crypto_op_class_type_t
Definition: crypto.h:208
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1599
static_always_inline u32 vnet_crypto_process_ops_call_handler(vlib_main_t *vm, vnet_crypto_main_t *cm, vnet_crypto_op_id_t opt, vnet_crypto_op_t *ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops)
Definition: crypto.c:33
vnet_crypto_async_alg_t alg
Definition: crypto.h:289
#define ASSERT(truth)
uword * engine_index_by_name
Definition: crypto.h:425
u32 vnet_crypto_process_chained_ops(vlib_main_t *vm, vnet_crypto_op_t ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops)
Definition: crypto.c:105
u8 data[128]
Definition: ipsec_types.api:89
clib_bitmap_t * async_active_ids
Definition: crypto.h:420
u32 vnet_crypto_key_index_t
Definition: crypto.h:342
#define foreach_crypto_aead_async_alg
async crypto
Definition: crypto.h:75
static void vlib_node_set_state(vlib_main_t *vm, u32 node_index, vlib_node_state_t new_state)
Set node dispatch state.
Definition: node_funcs.h:148
vnet_crypto_async_op_data_t async_opt_data[VNET_CRYPTO_ASYNC_OP_N_IDS]
Definition: crypto.h:422
static void vnet_crypto_init_cipher_data(vnet_crypto_alg_t alg, vnet_crypto_op_id_t eid, vnet_crypto_op_id_t did, char *name, u8 is_aead)
Definition: crypto.c:596
vnet_crypto_async_op_id_t
Definition: crypto.h:156
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
void vnet_crypto_register_ops_handler_inline(vlib_main_t *vm, u32 engine_index, vnet_crypto_op_id_t opt, vnet_crypto_ops_handler_t *fn, vnet_crypto_chained_ops_handler_t *cfn)
Definition: crypto.c:197
typedef key
Definition: ipsec_types.api:85
u32 vnet_crypto_key_add_linked(vlib_main_t *vm, vnet_crypto_key_index_t index_crypto, vnet_crypto_key_index_t index_integ)
Use 2 created keys to generate new key for linked algs (cipher + integ) The returned key index is to ...
Definition: crypto.c:410
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
vnet_crypto_op_type_t type
Definition: crypto.h:280
int vnet_crypto_is_set_async_handler(vnet_crypto_async_op_id_t op)
Definition: crypto.c:587
void vnet_crypto_register_chained_ops_handler(vlib_main_t *vm, u32 engine_index, vnet_crypto_op_id_t opt, vnet_crypto_chained_ops_handler_t *fn)
Definition: crypto.c:251
#define hash_get_mem(h, key)
Definition: hash.h:269
vnet_crypto_ops_handler_t * ops_handlers[VNET_CRYPTO_N_OP_IDS]
Definition: crypto.h:399
vnet_crypto_frame_enqueue_t * enqueue_handlers[VNET_CRYPTO_ASYNC_OP_N_IDS]
Definition: crypto.h:402
vnet_crypto_op_status_t status
Definition: crypto.h:233
vnet_crypto_op_id_t
Definition: crypto.h:193
vlib_node_state_t
Definition: node.h:252
vnet_crypto_key_t * keys
Definition: crypto.h:424
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
vl_api_dhcp_client_state_t state
Definition: dhcp.api:201
static u32 vlib_num_workers()
Definition: threads.h:376
#define vec_foreach(var, vec)
Vector iterator.
vnet_crypto_ops_handler_t ** ops_handlers
Definition: crypto.h:416
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
u32 vnet_crypto_register_engine(vlib_main_t *vm, char *name, int prio, char *desc)
Definition: crypto.c:112
vnet_crypto_async_alg_t
Definition: crypto.h:142
vnet_crypto_main_t crypto_main
Definition: crypto.c:20
clib_error_t * vnet_crypto_init(vlib_main_t *vm)
Definition: crypto.c:661
#define foreach_crypto_cipher_alg
Definition: crypto.h:24