src/vnet/crypto/main.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

/* SPDX-License-Identifier: Apache-2.0
 * Copyright(c) 2025 Cisco Systems, Inc.
 */

#include <vlib/vlib.h>
#include <vnet/crypto/crypto.h>
#include <vnet/crypto/engine.h>

vnet_crypto_main_t crypto_main =
{
  .algs = {
#define _(n, s, ...)                                                          \
  [VNET_CRYPTO_ALG_##n] = {                                                   \
    .name = (s),                                                              \
    .op_by_type[VNET_CRYPTO_OP_TYPE_ENCRYPT] = VNET_CRYPTO_OP_##n##_ENC,      \
    .op_by_type[VNET_CRYPTO_OP_TYPE_DECRYPT] = VNET_CRYPTO_OP_##n##_DEC,      \
    __VA_ARGS__,                                                              \
  },
  foreach_crypto_cipher_alg foreach_crypto_aead_alg
#undef _

#define _(n, s)                                                               \
  [VNET_CRYPTO_ALG_HASH_##n] = {                                              \
    .name = (s),                                                              \
    .op_by_type[VNET_CRYPTO_OP_TYPE_HASH] = VNET_CRYPTO_OP_##n##_HASH,        \
  },                                                                          \
  [VNET_CRYPTO_ALG_HMAC_##n] = {                                              \
    .name = ("hmac-" s),                                                      \
    .op_by_type[VNET_CRYPTO_OP_TYPE_HMAC] = VNET_CRYPTO_OP_##n##_HMAC,        \
    .variable_key_length = 1,                                                 \
  },
  foreach_crypto_hash_alg
#undef _

#define _(n, s, k, t, a)                                                      \
  [VNET_CRYPTO_ALG_##n##_TAG##t##_AAD##a] = {                                 \
    .name = (s),                                                              \
    .op_by_type[VNET_CRYPTO_OP_TYPE_ENCRYPT] =                                \
      VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_ENC,                             \
    .op_by_type[VNET_CRYPTO_OP_TYPE_DECRYPT] =                                \
      VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_DEC,                             \
  },
  foreach_crypto_aead_async_alg
#undef _

#define _(c, h, s, k, d)                                                      \
  [VNET_CRYPTO_ALG_##c##_##h##_TAG##d] = {                                    \
    .name = (s),                                                              \
    .op_by_type[VNET_CRYPTO_OP_TYPE_ENCRYPT] =                                \
      VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC,                                \
    .op_by_type[VNET_CRYPTO_OP_TYPE_DECRYPT] =                                \
      VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC,                                \
  },
  foreach_crypto_link_async_alg
#undef _

  },
  .opt_data = {
#define _(n, s, ...)                                                          \
  [VNET_CRYPTO_OP_##n##_ENC] = {                                              \
      .alg = VNET_CRYPTO_ALG_##n,                                             \
      .type = VNET_CRYPTO_OP_TYPE_ENCRYPT,                                    \
  },                                                                          \
  [VNET_CRYPTO_OP_##n##_DEC] = {                                              \
      .alg = VNET_CRYPTO_ALG_##n,                                             \
      .type = VNET_CRYPTO_OP_TYPE_DECRYPT,                                    \
  },
  foreach_crypto_cipher_alg foreach_crypto_aead_alg
#undef _

#define _(n, s)                                                               \
  [VNET_CRYPTO_OP_##n##_HASH] = {                                             \
    .alg = VNET_CRYPTO_ALG_HASH_##n,                                          \
    .type = VNET_CRYPTO_OP_TYPE_HASH,                                         \
  },                                                                          \
  [VNET_CRYPTO_OP_##n##_HMAC] = {                                             \
    .alg = VNET_CRYPTO_ALG_HMAC_##n,                                          \
    .type = VNET_CRYPTO_OP_TYPE_HMAC,                                         \
  },
  foreach_crypto_hash_alg
#undef _

#define _(n, s, k, t, a)                                                      \
  [VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_ENC] = {                            \
      .alg = VNET_CRYPTO_ALG_##n##_TAG##t##_AAD##a,                           \
      .type = VNET_CRYPTO_OP_TYPE_ENCRYPT,                                    \
  },                                                                          \
  [VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_DEC] = {                            \
      .alg = VNET_CRYPTO_ALG_##n##_TAG##t##_AAD##a,                           \
      .type = VNET_CRYPTO_OP_TYPE_DECRYPT,                                    \
  },
  foreach_crypto_aead_async_alg
#undef _

#define _(c, h, s, k, d)                                                      \
  [VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC] = {                               \
      .alg = VNET_CRYPTO_ALG_##c##_##h##_TAG##d,                              \
      .type = VNET_CRYPTO_OP_TYPE_ENCRYPT,                                    \
  } ,                                                                         \
  [VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC] = {                               \
      .alg = VNET_CRYPTO_ALG_##c##_##h##_TAG##d,                              \
      .type = VNET_CRYPTO_OP_TYPE_DECRYPT,                                    \
  },
    foreach_crypto_link_async_alg
#undef _

  },
};