lib/librte_vhost/virtio_crypto.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 HUAWEI TECHNOLOGIES CO., LTD.
   3  */
   4
   5 #ifndef _VIRTIO_CRYPTO_H
   6 #define _VIRTIO_CRYPTO_H
   7
   8 #define VIRTIO_CRYPTO_SERVICE_CIPHER 0
   9 #define VIRTIO_CRYPTO_SERVICE_HASH   1
  10 #define VIRTIO_CRYPTO_SERVICE_MAC    2
  11 #define VIRTIO_CRYPTO_SERVICE_AEAD   3
  12
  13 #define VIRTIO_CRYPTO_OPCODE(service, op)   (((service) << 8) | (op))
  14
  15 struct virtio_crypto_ctrl_header {
  16 #define VIRTIO_CRYPTO_CIPHER_CREATE_SESSION \
  17            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x02)
  18 #define VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION \
  19            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x03)
  20 #define VIRTIO_CRYPTO_HASH_CREATE_SESSION \
  21            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x02)
  22 #define VIRTIO_CRYPTO_HASH_DESTROY_SESSION \
  23            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x03)
  24 #define VIRTIO_CRYPTO_MAC_CREATE_SESSION \
  25            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x02)
  26 #define VIRTIO_CRYPTO_MAC_DESTROY_SESSION \
  27            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x03)
  28 #define VIRTIO_CRYPTO_AEAD_CREATE_SESSION \
  29            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x02)
  30 #define VIRTIO_CRYPTO_AEAD_DESTROY_SESSION \
  31            VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x03)
  32         uint32_t opcode;
  33         uint32_t algo;
  34         uint32_t flag;
  35         /* data virtqueue id */
  36         uint32_t queue_id;
  37 };
  38
  39 struct virtio_crypto_cipher_session_para {
  40 #define VIRTIO_CRYPTO_NO_CIPHER                 0
  41 #define VIRTIO_CRYPTO_CIPHER_ARC4               1
  42 #define VIRTIO_CRYPTO_CIPHER_AES_ECB            2
  43 #define VIRTIO_CRYPTO_CIPHER_AES_CBC            3
  44 #define VIRTIO_CRYPTO_CIPHER_AES_CTR            4
  45 #define VIRTIO_CRYPTO_CIPHER_DES_ECB            5
  46 #define VIRTIO_CRYPTO_CIPHER_DES_CBC            6
  47 #define VIRTIO_CRYPTO_CIPHER_3DES_ECB           7
  48 #define VIRTIO_CRYPTO_CIPHER_3DES_CBC           8
  49 #define VIRTIO_CRYPTO_CIPHER_3DES_CTR           9
  50 #define VIRTIO_CRYPTO_CIPHER_KASUMI_F8          10
  51 #define VIRTIO_CRYPTO_CIPHER_SNOW3G_UEA2        11
  52 #define VIRTIO_CRYPTO_CIPHER_AES_F8             12
  53 #define VIRTIO_CRYPTO_CIPHER_AES_XTS            13
  54 #define VIRTIO_CRYPTO_CIPHER_ZUC_EEA3           14
  55         uint32_t algo;
  56         /* length of key */
  57         uint32_t keylen;
  58
  59 #define VIRTIO_CRYPTO_OP_ENCRYPT  1
  60 #define VIRTIO_CRYPTO_OP_DECRYPT  2
  61         /* encrypt or decrypt */
  62         uint32_t op;
  63         uint32_t padding;
  64 };
  65
  66 struct virtio_crypto_session_input {
  67         /* Device-writable part */
  68         uint64_t session_id;
  69         uint32_t status;
  70         uint32_t padding;
  71 };
  72
  73 struct virtio_crypto_cipher_session_req {
  74         struct virtio_crypto_cipher_session_para para;
  75         uint8_t padding[32];
  76 };
  77
  78 struct virtio_crypto_hash_session_para {
  79 #define VIRTIO_CRYPTO_NO_HASH            0
  80 #define VIRTIO_CRYPTO_HASH_MD5           1
  81 #define VIRTIO_CRYPTO_HASH_SHA1          2
  82 #define VIRTIO_CRYPTO_HASH_SHA_224       3
  83 #define VIRTIO_CRYPTO_HASH_SHA_256       4
  84 #define VIRTIO_CRYPTO_HASH_SHA_384       5
  85 #define VIRTIO_CRYPTO_HASH_SHA_512       6
  86 #define VIRTIO_CRYPTO_HASH_SHA3_224      7
  87 #define VIRTIO_CRYPTO_HASH_SHA3_256      8
  88 #define VIRTIO_CRYPTO_HASH_SHA3_384      9
  89 #define VIRTIO_CRYPTO_HASH_SHA3_512      10
  90 #define VIRTIO_CRYPTO_HASH_SHA3_SHAKE128      11
  91 #define VIRTIO_CRYPTO_HASH_SHA3_SHAKE256      12
  92         uint32_t algo;
  93         /* hash result length */
  94         uint32_t hash_result_len;
  95         uint8_t padding[8];
  96 };
  97
  98 struct virtio_crypto_hash_create_session_req {
  99         struct virtio_crypto_hash_session_para para;
 100         uint8_t padding[40];
 101 };
 102
 103 struct virtio_crypto_mac_session_para {
 104 #define VIRTIO_CRYPTO_NO_MAC                       0
 105 #define VIRTIO_CRYPTO_MAC_HMAC_MD5                 1
 106 #define VIRTIO_CRYPTO_MAC_HMAC_SHA1                2
 107 #define VIRTIO_CRYPTO_MAC_HMAC_SHA_224             3
 108 #define VIRTIO_CRYPTO_MAC_HMAC_SHA_256             4
 109 #define VIRTIO_CRYPTO_MAC_HMAC_SHA_384             5
 110 #define VIRTIO_CRYPTO_MAC_HMAC_SHA_512             6
 111 #define VIRTIO_CRYPTO_MAC_CMAC_3DES                25
 112 #define VIRTIO_CRYPTO_MAC_CMAC_AES                 26
 113 #define VIRTIO_CRYPTO_MAC_KASUMI_F9                27
 114 #define VIRTIO_CRYPTO_MAC_SNOW3G_UIA2              28
 115 #define VIRTIO_CRYPTO_MAC_GMAC_AES                 41
 116 #define VIRTIO_CRYPTO_MAC_GMAC_TWOFISH             42
 117 #define VIRTIO_CRYPTO_MAC_CBCMAC_AES               49
 118 #define VIRTIO_CRYPTO_MAC_CBCMAC_KASUMI_F9         50
 119 #define VIRTIO_CRYPTO_MAC_XCBC_AES                 53
 120         uint32_t algo;
 121         /* hash result length */
 122         uint32_t hash_result_len;
 123         /* length of authenticated key */
 124         uint32_t auth_key_len;
 125         uint32_t padding;
 126 };
 127
 128 struct virtio_crypto_mac_create_session_req {
 129         struct virtio_crypto_mac_session_para para;
 130         uint8_t padding[40];
 131 };
 132
 133 struct virtio_crypto_aead_session_para {
 134 #define VIRTIO_CRYPTO_NO_AEAD     0
 135 #define VIRTIO_CRYPTO_AEAD_GCM    1
 136 #define VIRTIO_CRYPTO_AEAD_CCM    2
 137 #define VIRTIO_CRYPTO_AEAD_CHACHA20_POLY1305  3
 138         uint32_t algo;
 139         /* length of key */
 140         uint32_t key_len;
 141         /* hash result length */
 142         uint32_t hash_result_len;
 143         /* length of the additional authenticated data (AAD) in bytes */
 144         uint32_t aad_len;
 145         /* encrypt or decrypt, See above VIRTIO_CRYPTO_OP_* */
 146         uint32_t op;
 147         uint32_t padding;
 148 };
 149
 150 struct virtio_crypto_aead_create_session_req {
 151         struct virtio_crypto_aead_session_para para;
 152         uint8_t padding[32];
 153 };
 154
 155 struct virtio_crypto_alg_chain_session_para {
 156 #define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER  1
 157 #define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH  2
 158         uint32_t alg_chain_order;
 159 /* Plain hash */
 160 #define VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN    1
 161 /* Authenticated hash (mac) */
 162 #define VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH     2
 163 /* Nested hash */
 164 #define VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED   3
 165         uint32_t hash_mode;
 166         struct virtio_crypto_cipher_session_para cipher_param;
 167         union {
 168                 struct virtio_crypto_hash_session_para hash_param;
 169                 struct virtio_crypto_mac_session_para mac_param;
 170                 uint8_t padding[16];
 171         } u;
 172         /* length of the additional authenticated data (AAD) in bytes */
 173         uint32_t aad_len;
 174         uint32_t padding;
 175 };
 176
 177 struct virtio_crypto_alg_chain_session_req {
 178         struct virtio_crypto_alg_chain_session_para para;
 179 };
 180
 181 struct virtio_crypto_sym_create_session_req {
 182         union {
 183                 struct virtio_crypto_cipher_session_req cipher;
 184                 struct virtio_crypto_alg_chain_session_req chain;
 185                 uint8_t padding[48];
 186         } u;
 187
 188         /* Device-readable part */
 189
 190 /* No operation */
 191 #define VIRTIO_CRYPTO_SYM_OP_NONE  0
 192 /* Cipher only operation on the data */
 193 #define VIRTIO_CRYPTO_SYM_OP_CIPHER  1
 194 /*
 195  * Chain any cipher with any hash or mac operation. The order
 196  * depends on the value of alg_chain_order param
 197  */
 198 #define VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING  2
 199         uint32_t op_type;
 200         uint32_t padding;
 201 };
 202
 203 struct virtio_crypto_destroy_session_req {
 204         /* Device-readable part */
 205         uint64_t  session_id;
 206         uint8_t padding[48];
 207 };
 208
 209 /* The request of the control virtqueue's packet */
 210 struct virtio_crypto_op_ctrl_req {
 211         struct virtio_crypto_ctrl_header header;
 212
 213         union {
 214                 struct virtio_crypto_sym_create_session_req
 215                         sym_create_session;
 216                 struct virtio_crypto_hash_create_session_req
 217                         hash_create_session;
 218                 struct virtio_crypto_mac_create_session_req
 219                         mac_create_session;
 220                 struct virtio_crypto_aead_create_session_req
 221                         aead_create_session;
 222                 struct virtio_crypto_destroy_session_req
 223                         destroy_session;
 224                 uint8_t padding[56];
 225         } u;
 226 };
 227
 228 struct virtio_crypto_op_header {
 229 #define VIRTIO_CRYPTO_CIPHER_ENCRYPT \
 230         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x00)
 231 #define VIRTIO_CRYPTO_CIPHER_DECRYPT \
 232         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x01)
 233 #define VIRTIO_CRYPTO_HASH \
 234         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x00)
 235 #define VIRTIO_CRYPTO_MAC \
 236         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x00)
 237 #define VIRTIO_CRYPTO_AEAD_ENCRYPT \
 238         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x00)
 239 #define VIRTIO_CRYPTO_AEAD_DECRYPT \
 240         VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x01)
 241         uint32_t opcode;
 242         /* algo should be service-specific algorithms */
 243         uint32_t algo;
 244         /* session_id should be service-specific algorithms */
 245         uint64_t session_id;
 246         /* control flag to control the request */
 247         uint32_t flag;
 248         uint32_t padding;
 249 };
 250
 251 struct virtio_crypto_cipher_para {
 252         /*
 253          * Byte Length of valid IV/Counter
 254          *
 255          * For block ciphers in CBC or F8 mode, or for Kasumi in F8 mode, or for
 256          *   SNOW3G in UEA2 mode, this is the length of the IV (which
 257          *   must be the same as the block length of the cipher).
 258          * For block ciphers in CTR mode, this is the length of the counter
 259          *   (which must be the same as the block length of the cipher).
 260          * For AES-XTS, this is the 128bit tweak, i, from IEEE Std 1619-2007.
 261          *
 262          * The IV/Counter will be updated after every partial cryptographic
 263          * operation.
 264          */
 265         uint32_t iv_len;
 266         /* length of source data */
 267         uint32_t src_data_len;
 268         /* length of dst data */
 269         uint32_t dst_data_len;
 270         uint32_t padding;
 271 };
 272
 273 struct virtio_crypto_hash_para {
 274         /* length of source data */
 275         uint32_t src_data_len;
 276         /* hash result length */
 277         uint32_t hash_result_len;
 278 };
 279
 280 struct virtio_crypto_mac_para {
 281         struct virtio_crypto_hash_para hash;
 282 };
 283
 284 struct virtio_crypto_aead_para {
 285         /*
 286          * Byte Length of valid IV data pointed to by the below iv_addr
 287          * parameter.
 288          *
 289          * For GCM mode, this is either 12 (for 96-bit IVs) or 16, in which
 290          *   case iv_addr points to J0.
 291          * For CCM mode, this is the length of the nonce, which can be in the
 292          *   range 7 to 13 inclusive.
 293          */
 294         uint32_t iv_len;
 295         /* length of additional auth data */
 296         uint32_t aad_len;
 297         /* length of source data */
 298         uint32_t src_data_len;
 299         /* length of dst data */
 300         uint32_t dst_data_len;
 301 };
 302
 303 struct virtio_crypto_cipher_data_req {
 304         /* Device-readable part */
 305         struct virtio_crypto_cipher_para para;
 306         uint8_t padding[24];
 307 };
 308
 309 struct virtio_crypto_hash_data_req {
 310         /* Device-readable part */
 311         struct virtio_crypto_hash_para para;
 312         uint8_t padding[40];
 313 };
 314
 315 struct virtio_crypto_mac_data_req {
 316         /* Device-readable part */
 317         struct virtio_crypto_mac_para para;
 318         uint8_t padding[40];
 319 };
 320
 321 struct virtio_crypto_alg_chain_data_para {
 322         uint32_t iv_len;
 323         /* Length of source data */
 324         uint32_t src_data_len;
 325         /* Length of destination data */
 326         uint32_t dst_data_len;
 327         /* Starting point for cipher processing in source data */
 328         uint32_t cipher_start_src_offset;
 329         /* Length of the source data that the cipher will be computed on */
 330         uint32_t len_to_cipher;
 331         /* Starting point for hash processing in source data */
 332         uint32_t hash_start_src_offset;
 333         /* Length of the source data that the hash will be computed on */
 334         uint32_t len_to_hash;
 335         /* Length of the additional auth data */
 336         uint32_t aad_len;
 337         /* Length of the hash result */
 338         uint32_t hash_result_len;
 339         uint32_t reserved;
 340 };
 341
 342 struct virtio_crypto_alg_chain_data_req {
 343         /* Device-readable part */
 344         struct virtio_crypto_alg_chain_data_para para;
 345 };
 346
 347 struct virtio_crypto_sym_data_req {
 348         union {
 349                 struct virtio_crypto_cipher_data_req cipher;
 350                 struct virtio_crypto_alg_chain_data_req chain;
 351                 uint8_t padding[40];
 352         } u;
 353
 354         /* See above VIRTIO_CRYPTO_SYM_OP_* */
 355         uint32_t op_type;
 356         uint32_t padding;
 357 };
 358
 359 struct virtio_crypto_aead_data_req {
 360         /* Device-readable part */
 361         struct virtio_crypto_aead_para para;
 362         uint8_t padding[32];
 363 };
 364
 365 /* The request of the data virtqueue's packet */
 366 struct virtio_crypto_op_data_req {
 367         struct virtio_crypto_op_header header;
 368
 369         union {
 370                 struct virtio_crypto_sym_data_req  sym_req;
 371                 struct virtio_crypto_hash_data_req hash_req;
 372                 struct virtio_crypto_mac_data_req mac_req;
 373                 struct virtio_crypto_aead_data_req aead_req;
 374                 uint8_t padding[48];
 375         } u;
 376 };
 377
 378 #define VIRTIO_CRYPTO_OK        0
 379 #define VIRTIO_CRYPTO_ERR       1
 380 #define VIRTIO_CRYPTO_BADMSG    2
 381 #define VIRTIO_CRYPTO_NOTSUPP   3
 382 #define VIRTIO_CRYPTO_INVSESS   4 /* Invalid session id */
 383
 384 /* The accelerator hardware is ready */
 385 #define VIRTIO_CRYPTO_S_HW_READY  (1 << 0)
 386
 387 struct virtio_crypto_config {
 388         /* See VIRTIO_CRYPTO_OP_* above */
 389         uint32_t  status;
 390
 391         /*
 392          * Maximum number of data queue
 393          */
 394         uint32_t  max_dataqueues;
 395
 396         /*
 397          * Specifies the services mask which the device support,
 398          * see VIRTIO_CRYPTO_SERVICE_* above
 399          */
 400         uint32_t crypto_services;
 401
 402         /* Detailed algorithms mask */
 403         uint32_t cipher_algo_l;
 404         uint32_t cipher_algo_h;
 405         uint32_t hash_algo;
 406         uint32_t mac_algo_l;
 407         uint32_t mac_algo_h;
 408         uint32_t aead_algo;
 409         /* Maximum length of cipher key */
 410         uint32_t max_cipher_key_len;
 411         /* Maximum length of authenticated key */
 412         uint32_t max_auth_key_len;
 413         uint32_t reserve;
 414         /* Maximum size of each crypto request's content */
 415         uint64_t max_size;
 416 };
 417
 418 struct virtio_crypto_inhdr {
 419         /* See VIRTIO_CRYPTO_* above */
 420         uint8_t status;
 421 };
 422 #endif /* _VIRTIO_CRYPTO_H */