drivers/crypto/ipsec_mb/pmd_aesni_mb_priv.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2021 Intel Corporation
   3  */
   4
   5 #ifndef _PMD_AESNI_MB_PRIV_H_
   6 #define _PMD_AESNI_MB_PRIV_H_
   7
   8 #include <intel-ipsec-mb.h>
   9
  10 #if defined(RTE_LIB_SECURITY)
  11 #define AESNI_MB_DOCSIS_SEC_ENABLED 1
  12 #include <rte_security.h>
  13 #include <rte_security_driver.h>
  14 #include <rte_ether.h>
  15 #endif
  16
  17 #include "ipsec_mb_private.h"
  18
  19 #define AES_CCM_DIGEST_MIN_LEN 4
  20 #define AES_CCM_DIGEST_MAX_LEN 16
  21 #define HMAC_MAX_BLOCK_SIZE 128
  22 #define HMAC_IPAD_VALUE                 (0x36)
  23 #define HMAC_OPAD_VALUE                 (0x5C)
  24
  25 static const struct rte_cryptodev_capabilities aesni_mb_capabilities[] = {
  26         {       /* MD5 HMAC */
  27                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  28                 {.sym = {
  29                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  30                         {.auth = {
  31                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,
  32                                 .block_size = 64,
  33                                 .key_size = {
  34                                         .min = 1,
  35                                         .max = 64,
  36                                         .increment = 1
  37                                 },
  38                                 .digest_size = {
  39                                         .min = 1,
  40                                         .max = 16,
  41                                         .increment = 1
  42                                 },
  43                                 .iv_size = { 0 }
  44                         }, }
  45                 }, }
  46         },
  47         {       /* SHA1 HMAC */
  48                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  49                 {.sym = {
  50                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  51                         {.auth = {
  52                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
  53                                 .block_size = 64,
  54                                 .key_size = {
  55                                         .min = 1,
  56                                         .max = 65535,
  57                                         .increment = 1
  58                                 },
  59                                 .digest_size = {
  60                                         .min = 1,
  61                                         .max = 20,
  62                                         .increment = 1
  63                                 },
  64                                 .iv_size = { 0 }
  65                         }, }
  66                 }, }
  67         },
  68         {       /* SHA1 */
  69                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  70                 {.sym = {
  71                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  72                         {.auth = {
  73                                 .algo = RTE_CRYPTO_AUTH_SHA1,
  74                                 .block_size = 64,
  75                                 .key_size = {
  76                                         .min = 0,
  77                                         .max = 0,
  78                                         .increment = 0
  79                                 },
  80                                 .digest_size = {
  81                                         .min = 1,
  82                                         .max = 20,
  83                                         .increment = 1
  84                                 },
  85                                 .iv_size = { 0 }
  86                         }, }
  87                 }, }
  88         },
  89         {       /* SHA224 HMAC */
  90                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  91                 {.sym = {
  92                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  93                         {.auth = {
  94                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
  95                                 .block_size = 64,
  96                                 .key_size = {
  97                                         .min = 1,
  98                                         .max = 65535,
  99                                         .increment = 1
 100                                 },
 101                                 .digest_size = {
 102                                         .min = 1,
 103                                         .max = 28,
 104                                         .increment = 1
 105                                 },
 106                                 .iv_size = { 0 }
 107                         }, }
 108                 }, }
 109         },
 110         {       /* SHA224 */
 111                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 112                 {.sym = {
 113                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 114                         {.auth = {
 115                                 .algo = RTE_CRYPTO_AUTH_SHA224,
 116                                 .block_size = 64,
 117                                 .key_size = {
 118                                         .min = 0,
 119                                         .max = 0,
 120                                         .increment = 0
 121                                 },
 122                                 .digest_size = {
 123                                         .min = 1,
 124                                         .max = 28,
 125                                         .increment = 1
 126                                 },
 127                                 .iv_size = { 0 }
 128                         }, }
 129                 }, }
 130         },
 131         {       /* SHA256 HMAC */
 132                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 133                 {.sym = {
 134                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 135                         {.auth = {
 136                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 137                                 .block_size = 64,
 138                                 .key_size = {
 139                                         .min = 1,
 140                                         .max = 65535,
 141                                         .increment = 1
 142                                 },
 143                                 .digest_size = {
 144                                         .min = 1,
 145                                         .max = 32,
 146                                         .increment = 1
 147                                 },
 148                                 .iv_size = { 0 }
 149                         }, }
 150                 }, }
 151         },
 152         {       /* SHA256 */
 153                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 154                 {.sym = {
 155                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 156                         {.auth = {
 157                                 .algo = RTE_CRYPTO_AUTH_SHA256,
 158                                 .block_size = 64,
 159                                 .key_size = {
 160                                         .min = 0,
 161                                         .max = 0,
 162                                         .increment = 0
 163                                 },
 164                                 .digest_size = {
 165                                         .min = 1,
 166                                         .max = 32,
 167                                         .increment = 1
 168                                 },
 169                                 .iv_size = { 0 }
 170                         }, }
 171                 }, }
 172         },
 173         {       /* SHA384 HMAC */
 174                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 175                 {.sym = {
 176                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 177                         {.auth = {
 178                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 179                                 .block_size = 128,
 180                                 .key_size = {
 181                                         .min = 1,
 182                                         .max = 65535,
 183                                         .increment = 1
 184                                 },
 185                                 .digest_size = {
 186                                         .min = 1,
 187                                         .max = 48,
 188                                         .increment = 1
 189                                 },
 190                                 .iv_size = { 0 }
 191                         }, }
 192                 }, }
 193         },
 194         {       /* SHA384 */
 195                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 196                 {.sym = {
 197                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 198                         {.auth = {
 199                                 .algo = RTE_CRYPTO_AUTH_SHA384,
 200                                 .block_size = 128,
 201                                 .key_size = {
 202                                         .min = 0,
 203                                         .max = 0,
 204                                         .increment = 0
 205                                 },
 206                                 .digest_size = {
 207                                         .min = 1,
 208                                         .max = 48,
 209                                         .increment = 1
 210                                 },
 211                                 .iv_size = { 0 }
 212                         }, }
 213                 }, }
 214         },
 215         {       /* SHA512 HMAC */
 216                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 217                 {.sym = {
 218                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 219                         {.auth = {
 220                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 221                                 .block_size = 128,
 222                                 .key_size = {
 223                                         .min = 1,
 224                                         .max = 65535,
 225                                         .increment = 1
 226                                 },
 227                                 .digest_size = {
 228                                         .min = 1,
 229                                         .max = 64,
 230                                         .increment = 1
 231                                 },
 232                                 .iv_size = { 0 }
 233                         }, }
 234                 }, }
 235         },
 236         {       /* SHA512  */
 237                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 238                 {.sym = {
 239                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 240                         {.auth = {
 241                                 .algo = RTE_CRYPTO_AUTH_SHA512,
 242                                 .block_size = 128,
 243                                 .key_size = {
 244                                         .min = 0,
 245                                         .max = 0,
 246                                         .increment = 0
 247                                 },
 248                                 .digest_size = {
 249                                         .min = 1,
 250                                         .max = 64,
 251                                         .increment = 1
 252                                 },
 253                                 .iv_size = { 0 }
 254                         }, }
 255                 }, }
 256         },
 257         {       /* AES XCBC HMAC */
 258                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 259                 {.sym = {
 260                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 261                         {.auth = {
 262                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 263                                 .block_size = 16,
 264                                 .key_size = {
 265                                         .min = 16,
 266                                         .max = 16,
 267                                         .increment = 0
 268                                 },
 269                                 .digest_size = {
 270                                         .min = 12,
 271                                         .max = 12,
 272                                         .increment = 0
 273                                 },
 274                                 .iv_size = { 0 }
 275                         }, }
 276                 }, }
 277         },
 278         {       /* AES CBC */
 279                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 280                 {.sym = {
 281                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 282                         {.cipher = {
 283                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 284                                 .block_size = 16,
 285                                 .key_size = {
 286                                         .min = 16,
 287                                         .max = 32,
 288                                         .increment = 8
 289                                 },
 290                                 .iv_size = {
 291                                         .min = 16,
 292                                         .max = 16,
 293                                         .increment = 0
 294                                 }
 295                         }, }
 296                 }, }
 297         },
 298         {       /* AES CTR */
 299                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 300                 {.sym = {
 301                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 302                         {.cipher = {
 303                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 304                                 .block_size = 16,
 305                                 .key_size = {
 306                                         .min = 16,
 307                                         .max = 32,
 308                                         .increment = 8
 309                                 },
 310                                 .iv_size = {
 311                                         .min = 12,
 312                                         .max = 16,
 313                                         .increment = 4
 314                                 }
 315                         }, }
 316                 }, }
 317         },
 318         {       /* AES DOCSIS BPI */
 319                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 320                 {.sym = {
 321                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 322                         {.cipher = {
 323                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
 324                                 .block_size = 16,
 325                                 .key_size = {
 326                                         .min = 16,
 327                                         .max = 32,
 328                                         .increment = 16
 329                                 },
 330                                 .iv_size = {
 331                                         .min = 16,
 332                                         .max = 16,
 333                                         .increment = 0
 334                                 }
 335                         }, }
 336                 }, }
 337         },
 338         {       /* DES CBC */
 339                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 340                 {.sym = {
 341                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 342                         {.cipher = {
 343                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,
 344                                 .block_size = 8,
 345                                 .key_size = {
 346                                         .min = 8,
 347                                         .max = 8,
 348                                         .increment = 0
 349                                 },
 350                                 .iv_size = {
 351                                         .min = 8,
 352                                         .max = 8,
 353                                         .increment = 0
 354                                 }
 355                         }, }
 356                 }, }
 357         },
 358         {       /*  3DES CBC */
 359                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 360                 {.sym = {
 361                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 362                         {.cipher = {
 363                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 364                                 .block_size = 8,
 365                                 .key_size = {
 366                                         .min = 8,
 367                                         .max = 24,
 368                                         .increment = 8
 369                                 },
 370                                 .iv_size = {
 371                                         .min = 8,
 372                                         .max = 8,
 373                                         .increment = 0
 374                                 }
 375                         }, }
 376                 }, }
 377         },
 378         {       /* DES DOCSIS BPI */
 379                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 380                 {.sym = {
 381                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 382                         {.cipher = {
 383                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,
 384                                 .block_size = 8,
 385                                 .key_size = {
 386                                         .min = 8,
 387                                         .max = 8,
 388                                         .increment = 0
 389                                 },
 390                                 .iv_size = {
 391                                         .min = 8,
 392                                         .max = 8,
 393                                         .increment = 0
 394                                 }
 395                         }, }
 396                 }, }
 397         },
 398         {       /* AES CCM */
 399                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 400                 {.sym = {
 401                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 402                         {.aead = {
 403                                 .algo = RTE_CRYPTO_AEAD_AES_CCM,
 404                                 .block_size = 16,
 405                                 .key_size = {
 406                                         .min = 16,
 407                                         .max = 32,
 408                                         .increment = 16
 409                                 },
 410                                 .digest_size = {
 411                                         .min = 4,
 412                                         .max = 16,
 413                                         .increment = 2
 414                                 },
 415                                 .aad_size = {
 416                                         .min = 0,
 417                                         .max = 46,
 418                                         .increment = 1
 419                                 },
 420                                 .iv_size = {
 421                                         .min = 7,
 422                                         .max = 13,
 423                                         .increment = 1
 424                                 },
 425                         }, }
 426                 }, }
 427         },
 428         {       /* AES CMAC */
 429                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 430                 {.sym = {
 431                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 432                         {.auth = {
 433                                 .algo = RTE_CRYPTO_AUTH_AES_CMAC,
 434                                 .block_size = 16,
 435                                 .key_size = {
 436                                         .min = 16,
 437                                         .max = 16,
 438                                         .increment = 0
 439                                 },
 440                                 .digest_size = {
 441                                         .min = 1,
 442                                         .max = 16,
 443                                         .increment = 1
 444                                 },
 445                                 .iv_size = { 0 }
 446                         }, }
 447                 }, }
 448         },
 449         {       /* AES GCM */
 450                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 451                 {.sym = {
 452                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 453                         {.aead = {
 454                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 455                                 .block_size = 16,
 456                                 .key_size = {
 457                                         .min = 16,
 458                                         .max = 32,
 459                                         .increment = 8
 460                                 },
 461                                 .digest_size = {
 462                                         .min = 1,
 463                                         .max = 16,
 464                                         .increment = 1
 465                                 },
 466                                 .aad_size = {
 467                                         .min = 0,
 468                                         .max = 65535,
 469                                         .increment = 1
 470                                 },
 471                                 .iv_size = {
 472                                         .min = 12,
 473                                         .max = 12,
 474                                         .increment = 0
 475                                 }
 476                         }, }
 477                 }, }
 478         },
 479         {       /* AES GMAC (AUTH) */
 480                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 481                 {.sym = {
 482                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 483                         {.auth = {
 484                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,
 485                                 .block_size = 16,
 486                                 .key_size = {
 487                                         .min = 16,
 488                                         .max = 32,
 489                                         .increment = 8
 490                                 },
 491                                 .digest_size = {
 492                                         .min = 1,
 493                                         .max = 16,
 494                                         .increment = 1
 495                                 },
 496                                 .iv_size = {
 497                                         .min = 12,
 498                                         .max = 12,
 499                                         .increment = 0
 500                                 }
 501                         }, }
 502                 }, }
 503         },
 504         {       /* AES ECB */
 505                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 506                 {.sym = {
 507                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 508                         {.cipher = {
 509                                 .algo = RTE_CRYPTO_CIPHER_AES_ECB,
 510                                 .block_size = 16,
 511                                 .key_size = {
 512                                         .min = 16,
 513                                         .max = 32,
 514                                         .increment = 8
 515                                 },
 516                                 .iv_size = { 0 }
 517                         }, }
 518                 }, }
 519         },
 520         {       /* ZUC (EIA3) */
 521                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 522                 {.sym = {
 523                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 524                         {.auth = {
 525                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,
 526                                 .block_size = 16,
 527                                 .key_size = {
 528                                         .min = 16,
 529                                         .max = 32,
 530                                         .increment = 16
 531                                 },
 532                                 .digest_size = {
 533                                         .min = 4,
 534                                         .max = 4,
 535                                         .increment = 0
 536                                 },
 537                                 .iv_size = {
 538                                         .min = 16,
 539                                         .max = 25,
 540                                         .increment = 9
 541                                 }
 542                         }, }
 543                 }, }
 544         },
 545         {       /* ZUC (EEA3) */
 546                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 547                 {.sym = {
 548                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 549                         {.cipher = {
 550                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,
 551                                 .block_size = 16,
 552                                 .key_size = {
 553                                         .min = 16,
 554                                         .max = 32,
 555                                         .increment = 16
 556                                 },
 557                                 .iv_size = {
 558                                         .min = 16,
 559                                         .max = 25,
 560                                         .increment = 9
 561                                 },
 562                         }, }
 563                 }, }
 564         },
 565         {       /* SNOW 3G (UIA2) */
 566                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 567                 {.sym = {
 568                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 569                         {.auth = {
 570                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 571                                 .block_size = 16,
 572                                 .key_size = {
 573                                         .min = 16,
 574                                         .max = 16,
 575                                         .increment = 0
 576                                 },
 577                                 .digest_size = {
 578                                         .min = 4,
 579                                         .max = 4,
 580                                         .increment = 0
 581                                 },
 582                                 .iv_size = {
 583                                         .min = 16,
 584                                         .max = 16,
 585                                         .increment = 0
 586                                 }
 587                         }, }
 588                 }, }
 589         },
 590         {       /* SNOW 3G (UEA2) */
 591                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 592                 {.sym = {
 593                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 594                         {.cipher = {
 595                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 596                                 .block_size = 16,
 597                                 .key_size = {
 598                                         .min = 16,
 599                                         .max = 16,
 600                                         .increment = 0
 601                                 },
 602                                 .iv_size = {
 603                                         .min = 16,
 604                                         .max = 16,
 605                                         .increment = 0
 606                                 }
 607                         }, }
 608                 }, }
 609         },
 610         {       /* KASUMI (F9) */
 611                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 612                 {.sym = {
 613                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 614                         {.auth = {
 615                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,
 616                                 .block_size = 8,
 617                                 .key_size = {
 618                                         .min = 16,
 619                                         .max = 16,
 620                                         .increment = 0
 621                                 },
 622                                 .digest_size = {
 623                                         .min = 4,
 624                                         .max = 4,
 625                                         .increment = 0
 626                                 },
 627                                 .iv_size = { 0 }
 628                         }, }
 629                 }, }
 630         },
 631         {       /* KASUMI (F8) */
 632                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 633                 {.sym = {
 634                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 635                         {.cipher = {
 636                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,
 637                                 .block_size = 8,
 638                                 .key_size = {
 639                                         .min = 16,
 640                                         .max = 16,
 641                                         .increment = 0
 642                                 },
 643                                 .iv_size = {
 644                                         .min = 8,
 645                                         .max = 8,
 646                                         .increment = 0
 647                                 }
 648                         }, }
 649                 }, }
 650         },
 651         {       /* CHACHA20-POLY1305 */
 652                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 653                 {.sym = {
 654                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 655                         {.aead = {
 656                                 .algo = RTE_CRYPTO_AEAD_CHACHA20_POLY1305,
 657                                 .block_size = 64,
 658                                 .key_size = {
 659                                         .min = 32,
 660                                         .max = 32,
 661                                         .increment = 0
 662                                 },
 663                                 .digest_size = {
 664                                         .min = 16,
 665                                         .max = 16,
 666                                         .increment = 0
 667                                 },
 668                                 .aad_size = {
 669                                         .min = 0,
 670                                         .max = 1024,
 671                                         .increment = 1
 672                                 },
 673                                 .iv_size = {
 674                                         .min = 12,
 675                                         .max = 12,
 676                                         .increment = 0
 677                                 },
 678                         }, }
 679                 }, }
 680         },
 681         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 682 };
 683
 684 uint8_t pmd_driver_id_aesni_mb;
 685
 686 struct aesni_mb_qp_data {
 687         uint8_t temp_digests[IMB_MAX_JOBS][DIGEST_LENGTH_MAX];
 688         /* *< Buffers used to store the digest generated
 689          * by the driver when verifying a digest provided
 690          * by the user (using authentication verify operation)
 691          */
 692 };
 693
 694 /* Maximum length for digest */
 695 #define DIGEST_LENGTH_MAX 64
 696 static const unsigned int auth_blocksize[] = {
 697                 [IMB_AUTH_NULL]                 = 0,
 698                 [IMB_AUTH_MD5]                  = 64,
 699                 [IMB_AUTH_HMAC_SHA_1]           = 64,
 700                 [IMB_AUTH_HMAC_SHA_224]         = 64,
 701                 [IMB_AUTH_HMAC_SHA_256]         = 64,
 702                 [IMB_AUTH_HMAC_SHA_384]         = 128,
 703                 [IMB_AUTH_HMAC_SHA_512]         = 128,
 704                 [IMB_AUTH_AES_XCBC]             = 16,
 705                 [IMB_AUTH_AES_CCM]              = 16,
 706                 [IMB_AUTH_AES_CMAC]             = 16,
 707                 [IMB_AUTH_AES_GMAC]             = 16,
 708                 [IMB_AUTH_SHA_1]                = 64,
 709                 [IMB_AUTH_SHA_224]              = 64,
 710                 [IMB_AUTH_SHA_256]              = 64,
 711                 [IMB_AUTH_SHA_384]              = 128,
 712                 [IMB_AUTH_SHA_512]              = 128,
 713                 [IMB_AUTH_ZUC_EIA3_BITLEN]      = 16,
 714                 [IMB_AUTH_SNOW3G_UIA2_BITLEN]   = 16,
 715                 [IMB_AUTH_KASUMI_UIA1]          = 16
 716 };
 717
 718 /**
 719  * Get the blocksize in bytes for a specified authentication algorithm
 720  *
 721  * @Note: this function will not return a valid value for a non-valid
 722  * authentication algorithm
 723  */
 724 static inline unsigned int
 725 get_auth_algo_blocksize(IMB_HASH_ALG algo)
 726 {
 727         return auth_blocksize[algo];
 728 }
 729
 730 static const unsigned int auth_truncated_digest_byte_lengths[] = {
 731                 [IMB_AUTH_MD5]                  = 12,
 732                 [IMB_AUTH_HMAC_SHA_1]           = 12,
 733                 [IMB_AUTH_HMAC_SHA_224]         = 14,
 734                 [IMB_AUTH_HMAC_SHA_256]         = 16,
 735                 [IMB_AUTH_HMAC_SHA_384]         = 24,
 736                 [IMB_AUTH_HMAC_SHA_512]         = 32,
 737                 [IMB_AUTH_AES_XCBC]             = 12,
 738                 [IMB_AUTH_AES_CMAC]             = 12,
 739                 [IMB_AUTH_AES_CCM]              = 8,
 740                 [IMB_AUTH_NULL]                 = 0,
 741                 [IMB_AUTH_AES_GMAC]             = 12,
 742                 [IMB_AUTH_SHA_1]                = 20,
 743                 [IMB_AUTH_SHA_224]              = 28,
 744                 [IMB_AUTH_SHA_256]              = 32,
 745                 [IMB_AUTH_SHA_384]              = 48,
 746                 [IMB_AUTH_SHA_512]              = 64,
 747                 [IMB_AUTH_ZUC_EIA3_BITLEN]      = 4,
 748                 [IMB_AUTH_SNOW3G_UIA2_BITLEN]   = 4,
 749                 [IMB_AUTH_KASUMI_UIA1]          = 4
 750 };
 751
 752 /**
 753  * Get the IPsec specified truncated length in bytes of the HMAC digest for a
 754  * specified authentication algorithm
 755  *
 756  * @Note: this function will not return a valid value for a non-valid
 757  * authentication algorithm
 758  */
 759 static inline unsigned int
 760 get_truncated_digest_byte_length(IMB_HASH_ALG algo)
 761 {
 762         return auth_truncated_digest_byte_lengths[algo];
 763 }
 764
 765 static const unsigned int auth_digest_byte_lengths[] = {
 766                 [IMB_AUTH_MD5]                  = 16,
 767                 [IMB_AUTH_HMAC_SHA_1]           = 20,
 768                 [IMB_AUTH_HMAC_SHA_224]         = 28,
 769                 [IMB_AUTH_HMAC_SHA_256]         = 32,
 770                 [IMB_AUTH_HMAC_SHA_384]         = 48,
 771                 [IMB_AUTH_HMAC_SHA_512]         = 64,
 772                 [IMB_AUTH_AES_XCBC]             = 16,
 773                 [IMB_AUTH_AES_CMAC]             = 16,
 774                 [IMB_AUTH_AES_CCM]              = 16,
 775                 [IMB_AUTH_AES_GMAC]             = 16,
 776                 [IMB_AUTH_NULL]                 = 0,
 777                 [IMB_AUTH_SHA_1]                = 20,
 778                 [IMB_AUTH_SHA_224]              = 28,
 779                 [IMB_AUTH_SHA_256]              = 32,
 780                 [IMB_AUTH_SHA_384]              = 48,
 781                 [IMB_AUTH_SHA_512]              = 64,
 782                 [IMB_AUTH_ZUC_EIA3_BITLEN]      = 4,
 783                 [IMB_AUTH_SNOW3G_UIA2_BITLEN]   = 4,
 784                 [IMB_AUTH_KASUMI_UIA1]          = 4
 785         /**< Vector mode dependent pointer table of the multi-buffer APIs */
 786
 787 };
 788
 789 /**
 790  * Get the full digest size in bytes for a specified authentication algorithm
 791  * (if available in the Multi-buffer library)
 792  *
 793  * @Note: this function will not return a valid value for a non-valid
 794  * authentication algorithm
 795  */
 796 static inline unsigned int
 797 get_digest_byte_length(IMB_HASH_ALG algo)
 798 {
 799         return auth_digest_byte_lengths[algo];
 800 }
 801
 802 /** AES-NI multi-buffer private session structure */
 803 struct aesni_mb_session {
 804         IMB_CIPHER_MODE cipher_mode;
 805         IMB_CIPHER_DIRECTION cipher_direction;
 806         IMB_HASH_ALG hash_alg;
 807         IMB_CHAIN_ORDER chain_order;
 808         /*  common job fields */
 809         struct {
 810                 uint16_t length;
 811                 uint16_t offset;
 812         } iv;
 813         struct {
 814                 uint16_t length;
 815                 uint16_t offset;
 816         } auth_iv;
 817         /* *< IV parameters
 818          */
 819
 820         /* * Cipher Parameters
 821          */
 822         struct {
 823                 /* * Cipher direction - encrypt / decrypt */
 824                 IMB_CIPHER_DIRECTION direction;
 825                 /* * Cipher mode - CBC / Counter */
 826                 IMB_CIPHER_MODE mode;
 827
 828                 uint64_t key_length_in_bytes;
 829
 830                 union {
 831                         struct {
 832                                 uint32_t encode[60] __rte_aligned(16);
 833                                 /* *< encode key */
 834                                 uint32_t decode[60] __rte_aligned(16);
 835                                 /* *< decode key */
 836                         } expanded_aes_keys;
 837                         /* *< Expanded AES keys - Allocating space to
 838                          * contain the maximum expanded key size which
 839                          * is 240 bytes for 256 bit AES, calculate by:
 840                          * ((key size (bytes)) *
 841                          * ((number of rounds) + 1))
 842                          */
 843                         struct {
 844                                 const void *ks_ptr[3];
 845                                 uint64_t key[3][16];
 846                         } exp_3des_keys;
 847                         /* *< Expanded 3DES keys */
 848
 849                         struct gcm_key_data gcm_key;
 850                         /* *< Expanded GCM key */
 851                         uint8_t zuc_cipher_key[16];
 852                         /* *< ZUC cipher key */
 853                         snow3g_key_schedule_t pKeySched_snow3g_cipher;
 854                         /* *< SNOW3G scheduled cipher key */
 855                         kasumi_key_sched_t pKeySched_kasumi_cipher;
 856                         /* *< KASUMI scheduled cipher key */
 857                 };
 858         } cipher;
 859
 860         /* *< Authentication Parameters */
 861         struct {
 862                 IMB_HASH_ALG algo; /* *< Authentication Algorithm */
 863                 enum rte_crypto_auth_operation operation;
 864                 /* *< auth operation generate or verify */
 865                 union {
 866                         struct {
 867                                 uint8_t inner[128] __rte_aligned(16);
 868                                 /* *< inner pad */
 869                                 uint8_t outer[128] __rte_aligned(16);
 870                                 /* *< outer pad */
 871                         } pads;
 872                         /* *< HMAC Authentication pads -
 873                          * allocating space for the maximum pad
 874                          * size supported which is 128 bytes for
 875                          * SHA512
 876                          */
 877
 878                         struct {
 879                                 uint32_t k1_expanded[44] __rte_aligned(16);
 880                                 /* *< k1 (expanded key). */
 881                                 uint8_t k2[16] __rte_aligned(16);
 882                                 /* *< k2. */
 883                                 uint8_t k3[16] __rte_aligned(16);
 884                                 /* *< k3. */
 885                         } xcbc;
 886
 887                         struct {
 888                                 uint32_t expkey[60] __rte_aligned(16);
 889                                 /* *< k1 (expanded key). */
 890                                 uint32_t skey1[4] __rte_aligned(16);
 891                                 /* *< k2. */
 892                                 uint32_t skey2[4] __rte_aligned(16);
 893                                 /* *< k3. */
 894                         } cmac;
 895                         /* *< Expanded XCBC authentication keys */
 896                         uint8_t zuc_auth_key[16];
 897                         /* *< ZUC authentication key */
 898                         snow3g_key_schedule_t pKeySched_snow3g_auth;
 899                         /* *< SNOW3G scheduled authentication key */
 900                         kasumi_key_sched_t pKeySched_kasumi_auth;
 901                         /* *< KASUMI scheduled authentication key */
 902                 };
 903                 /* * Generated digest size by the Multi-buffer library */
 904                 uint16_t gen_digest_len;
 905                 /* * Requested digest size from Cryptodev */
 906                 uint16_t req_digest_len;
 907
 908         } auth;
 909         struct {
 910                 /* * AAD data length */
 911                 uint16_t aad_len;
 912         } aead;
 913 } __rte_cache_aligned;
 914
 915 typedef void (*hash_one_block_t)(const void *data, void *digest);
 916 typedef void (*aes_keyexp_t)(const void *key, void *enc_exp_keys,
 917                         void *dec_exp_keys);
 918
 919 #ifdef AESNI_MB_DOCSIS_SEC_ENABLED
 920 static const struct rte_cryptodev_capabilities
 921                                         aesni_mb_pmd_security_crypto_cap[] = {
 922         {       /* AES DOCSIS BPI */
 923                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 924                 {.sym = {
 925                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 926                         {.cipher = {
 927                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
 928                                 .block_size = 16,
 929                                 .key_size = {
 930                                         .min = 16,
 931                                         .max = 32,
 932                                         .increment = 16
 933                                 },
 934                                 .iv_size = {
 935                                         .min = 16,
 936                                         .max = 16,
 937                                         .increment = 0
 938                                 }
 939                         }, }
 940                 }, }
 941         },
 942
 943         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 944 };
 945
 946 static const struct rte_security_capability aesni_mb_pmd_security_cap[] = {
 947         {       /* DOCSIS Uplink */
 948                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 949                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
 950                 .docsis = {
 951                         .direction = RTE_SECURITY_DOCSIS_UPLINK
 952                 },
 953                 .crypto_capabilities = aesni_mb_pmd_security_crypto_cap
 954         },
 955         {       /* DOCSIS Downlink */
 956                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 957                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
 958                 .docsis = {
 959                         .direction = RTE_SECURITY_DOCSIS_DOWNLINK
 960                 },
 961                 .crypto_capabilities = aesni_mb_pmd_security_crypto_cap
 962         },
 963         {
 964                 .action = RTE_SECURITY_ACTION_TYPE_NONE
 965         }
 966 };
 967 #endif
 968
 969 #endif /* _PMD_AESNI_MB_PRIV_H_ */