src/plugins/crypto_native/aes_cbc.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2019 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vnet/plugin/plugin.h>
  20 #include <vnet/crypto/crypto.h>
  21 #include <crypto_native/crypto_native.h>
  22 #include <crypto_native/aes.h>
  23
  24 #if __GNUC__ > 4  && !__clang__ && CLIB_DEBUG == 0
  25 #pragma GCC optimize ("O3")
  26 #endif
  27
  28 typedef struct
  29 {
  30   u8x16 encrypt_key[15];
  31 #if __VAES__
  32   u8x64 decrypt_key[15];
  33 #else
  34   u8x16 decrypt_key[15];
  35 #endif
  36 } aes_cbc_key_data_t;
  37
  38
  39 static_always_inline void __clib_unused
  40 aes_cbc_dec (u8x16 * k, u8x16u * src, u8x16u * dst, u8x16u * iv, int count,
  41              int rounds)
  42 {
  43   u8x16 r[4], c[4], f;
  44
  45   f = iv[0];
  46   while (count >= 64)
  47     {
  48       clib_prefetch_load (src + 8);
  49       clib_prefetch_load (dst + 8);
  50
  51       c[0] = r[0] = src[0];
  52       c[1] = r[1] = src[1];
  53       c[2] = r[2] = src[2];
  54       c[3] = r[3] = src[3];
  55
  56 #if __x86_64__
  57       r[0] ^= k[0];
  58       r[1] ^= k[0];
  59       r[2] ^= k[0];
  60       r[3] ^= k[0];
  61
  62       for (int i = 1; i < rounds; i++)
  63         {
  64           r[0] = aes_dec_round (r[0], k[i]);
  65           r[1] = aes_dec_round (r[1], k[i]);
  66           r[2] = aes_dec_round (r[2], k[i]);
  67           r[3] = aes_dec_round (r[3], k[i]);
  68         }
  69
  70       r[0] = aes_dec_last_round (r[0], k[rounds]);
  71       r[1] = aes_dec_last_round (r[1], k[rounds]);
  72       r[2] = aes_dec_last_round (r[2], k[rounds]);
  73       r[3] = aes_dec_last_round (r[3], k[rounds]);
  74 #else
  75       for (int i = 0; i < rounds - 1; i++)
  76         {
  77           r[0] = vaesimcq_u8 (vaesdq_u8 (r[0], k[i]));
  78           r[1] = vaesimcq_u8 (vaesdq_u8 (r[1], k[i]));
  79           r[2] = vaesimcq_u8 (vaesdq_u8 (r[2], k[i]));
  80           r[3] = vaesimcq_u8 (vaesdq_u8 (r[3], k[i]));
  81         }
  82       r[0] = vaesdq_u8 (r[0], k[rounds - 1]) ^ k[rounds];
  83       r[1] = vaesdq_u8 (r[1], k[rounds - 1]) ^ k[rounds];
  84       r[2] = vaesdq_u8 (r[2], k[rounds - 1]) ^ k[rounds];
  85       r[3] = vaesdq_u8 (r[3], k[rounds - 1]) ^ k[rounds];
  86 #endif
  87       dst[0] = r[0] ^ f;
  88       dst[1] = r[1] ^ c[0];
  89       dst[2] = r[2] ^ c[1];
  90       dst[3] = r[3] ^ c[2];
  91       f = c[3];
  92
  93       count -= 64;
  94       src += 4;
  95       dst += 4;
  96     }
  97
  98   while (count > 0)
  99     {
 100       c[0] = r[0] = src[0];
 101 #if __x86_64__
 102       r[0] ^= k[0];
 103       for (int i = 1; i < rounds; i++)
 104         r[0] = aes_dec_round (r[0], k[i]);
 105       r[0] = aes_dec_last_round (r[0], k[rounds]);
 106 #else
 107       c[0] = r[0] = src[0];
 108       for (int i = 0; i < rounds - 1; i++)
 109         r[0] = vaesimcq_u8 (vaesdq_u8 (r[0], k[i]));
 110       r[0] = vaesdq_u8 (r[0], k[rounds - 1]) ^ k[rounds];
 111 #endif
 112       dst[0] = r[0] ^ f;
 113       f = c[0];
 114
 115       count -= 16;
 116       src += 1;
 117       dst += 1;
 118     }
 119 }
 120
 121 #if __x86_64__
 122 #ifdef __VAES__
 123
 124 static_always_inline u8x64
 125 aes_block_load_x4 (u8 * src[], int i)
 126 {
 127   u8x64 r = { };
 128   r = u8x64_insert_u8x16 (r, aes_block_load (src[0] + i), 0);
 129   r = u8x64_insert_u8x16 (r, aes_block_load (src[1] + i), 1);
 130   r = u8x64_insert_u8x16 (r, aes_block_load (src[2] + i), 2);
 131   r = u8x64_insert_u8x16 (r, aes_block_load (src[3] + i), 3);
 132   return r;
 133 }
 134
 135 static_always_inline void
 136 aes_block_store_x4 (u8 * dst[], int i, u8x64 r)
 137 {
 138   aes_block_store (dst[0] + i, u8x64_extract_u8x16 (r, 0));
 139   aes_block_store (dst[1] + i, u8x64_extract_u8x16 (r, 1));
 140   aes_block_store (dst[2] + i, u8x64_extract_u8x16 (r, 2));
 141   aes_block_store (dst[3] + i, u8x64_extract_u8x16 (r, 3));
 142 }
 143
 144 static_always_inline u8x64
 145 aes_cbc_dec_permute (u8x64 a, u8x64 b)
 146 {
 147   __m512i perm = { 6, 7, 8, 9, 10, 11, 12, 13 };
 148   return (u8x64) _mm512_permutex2var_epi64 ((__m512i) a, perm, (__m512i) b);
 149 }
 150
 151 static_always_inline void
 152 vaes_cbc_dec (u8x64 *k, u8x64u *src, u8x64u *dst, u8x16u *iv, int count,
 153               aes_key_size_t rounds)
 154 {
 155   u8x64 f, r[4], c[4] = { };
 156   __mmask8 m;
 157   int i, n_blocks = count >> 4;
 158
 159   f = (u8x64) _mm512_mask_loadu_epi64 (_mm512_setzero_si512 (), 0xc0,
 160                                        (__m512i *) (iv - 3));
 161
 162   while (n_blocks >= 16)
 163     {
 164       c[0] = src[0];
 165       c[1] = src[1];
 166       c[2] = src[2];
 167       c[3] = src[3];
 168
 169       r[0] = c[0] ^ k[0];
 170       r[1] = c[1] ^ k[0];
 171       r[2] = c[2] ^ k[0];
 172       r[3] = c[3] ^ k[0];
 173
 174       for (i = 1; i < rounds; i++)
 175         {
 176           r[0] = aes_dec_round_x4 (r[0], k[i]);
 177           r[1] = aes_dec_round_x4 (r[1], k[i]);
 178           r[2] = aes_dec_round_x4 (r[2], k[i]);
 179           r[3] = aes_dec_round_x4 (r[3], k[i]);
 180         }
 181
 182       r[0] = aes_dec_last_round_x4 (r[0], k[i]);
 183       r[1] = aes_dec_last_round_x4 (r[1], k[i]);
 184       r[2] = aes_dec_last_round_x4 (r[2], k[i]);
 185       r[3] = aes_dec_last_round_x4 (r[3], k[i]);
 186
 187       dst[0] = r[0] ^= aes_cbc_dec_permute (f, c[0]);
 188       dst[1] = r[1] ^= aes_cbc_dec_permute (c[0], c[1]);
 189       dst[2] = r[2] ^= aes_cbc_dec_permute (c[1], c[2]);
 190       dst[3] = r[3] ^= aes_cbc_dec_permute (c[2], c[3]);
 191       f = c[3];
 192
 193       n_blocks -= 16;
 194       src += 4;
 195       dst += 4;
 196     }
 197
 198   while (n_blocks > 0)
 199     {
 200       m = (1 << (n_blocks * 2)) - 1;
 201       c[0] = (u8x64) _mm512_mask_loadu_epi64 ((__m512i) c[0], m,
 202                                               (__m512i *) src);
 203       f = aes_cbc_dec_permute (f, c[0]);
 204       r[0] = c[0] ^ k[0];
 205       for (i = 1; i < rounds; i++)
 206         r[0] = aes_dec_round_x4 (r[0], k[i]);
 207       r[0] = aes_dec_last_round_x4 (r[0], k[i]);
 208       _mm512_mask_storeu_epi64 ((__m512i *) dst, m, (__m512i) (r[0] ^ f));
 209       f = c[0];
 210       n_blocks -= 4;
 211       src += 1;
 212       dst += 1;
 213     }
 214 }
 215 #endif
 216 #endif
 217
 218 #ifdef __VAES__
 219 #define N 16
 220 #define u32xN u32x16
 221 #define u32xN_min_scalar u32x16_min_scalar
 222 #define u32xN_is_all_zero u32x16_is_all_zero
 223 #define u32xN_splat u32x16_splat
 224 #else
 225 #define N 4
 226 #define u32xN u32x4
 227 #define u32xN_min_scalar u32x4_min_scalar
 228 #define u32xN_is_all_zero u32x4_is_all_zero
 229 #define u32xN_splat u32x4_splat
 230 #endif
 231
 232 static_always_inline u32
 233 aes_ops_enc_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
 234                      u32 n_ops, aes_key_size_t ks)
 235 {
 236   crypto_native_main_t *cm = &crypto_native_main;
 237   int rounds = AES_KEY_ROUNDS (ks);
 238   u8 placeholder[8192];
 239   u32 i, j, count, n_left = n_ops;
 240   u32xN placeholder_mask = { };
 241   u32xN len = { };
 242   vnet_crypto_key_index_t key_index[N];
 243   u8 *src[N] = { };
 244   u8 *dst[N] = { };
 245 #if __VAES__
 246   u8x64 r[N / 4] = { };
 247   u8x64 k[15][N / 4] = { };
 248   u8x16 *kq, *rq = (u8x16 *) r;
 249 #else
 250   u8x16 r[N] = { };
 251   u8x16 k[15][N] = { };
 252 #endif
 253
 254   for (i = 0; i < N; i++)
 255     key_index[i] = ~0;
 256
 257 more:
 258   for (i = 0; i < N; i++)
 259     if (len[i] == 0)
 260       {
 261         if (n_left == 0)
 262           {
 263             /* no more work to enqueue, so we are enqueueing placeholder buffer */
 264             src[i] = dst[i] = placeholder;
 265             len[i] = sizeof (placeholder);
 266             placeholder_mask[i] = 0;
 267           }
 268         else
 269           {
 270             u8x16 t = aes_block_load (ops[0]->iv);
 271 #if __VAES__
 272             rq[i] = t;
 273 #else
 274             r[i] = t;
 275 #endif
 276
 277             src[i] = ops[0]->src;
 278             dst[i] = ops[0]->dst;
 279             len[i] = ops[0]->len;
 280             placeholder_mask[i] = ~0;
 281             if (key_index[i] != ops[0]->key_index)
 282               {
 283                 aes_cbc_key_data_t *kd;
 284                 key_index[i] = ops[0]->key_index;
 285                 kd = (aes_cbc_key_data_t *) cm->key_data[key_index[i]];
 286                 for (j = 0; j < rounds + 1; j++)
 287                   {
 288 #if __VAES__
 289                     kq = (u8x16 *) k[j];
 290                     kq[i] = kd->encrypt_key[j];
 291 #else
 292                     k[j][i] = kd->encrypt_key[j];
 293 #endif
 294                   }
 295               }
 296             ops[0]->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 297             n_left--;
 298             ops++;
 299           }
 300       }
 301
 302   count = u32xN_min_scalar (len);
 303
 304   ASSERT (count % 16 == 0);
 305
 306   for (i = 0; i < count; i += 16)
 307     {
 308 #ifdef __VAES__
 309       r[0] = u8x64_xor3 (r[0], aes_block_load_x4 (src, i), k[0][0]);
 310       r[1] = u8x64_xor3 (r[1], aes_block_load_x4 (src + 4, i), k[0][1]);
 311       r[2] = u8x64_xor3 (r[2], aes_block_load_x4 (src + 8, i), k[0][2]);
 312       r[3] = u8x64_xor3 (r[3], aes_block_load_x4 (src + 12, i), k[0][3]);
 313
 314       for (j = 1; j < rounds; j++)
 315         {
 316           r[0] = aes_enc_round_x4 (r[0], k[j][0]);
 317           r[1] = aes_enc_round_x4 (r[1], k[j][1]);
 318           r[2] = aes_enc_round_x4 (r[2], k[j][2]);
 319           r[3] = aes_enc_round_x4 (r[3], k[j][3]);
 320         }
 321       r[0] = aes_enc_last_round_x4 (r[0], k[j][0]);
 322       r[1] = aes_enc_last_round_x4 (r[1], k[j][1]);
 323       r[2] = aes_enc_last_round_x4 (r[2], k[j][2]);
 324       r[3] = aes_enc_last_round_x4 (r[3], k[j][3]);
 325
 326       aes_block_store_x4 (dst, i, r[0]);
 327       aes_block_store_x4 (dst + 4, i, r[1]);
 328       aes_block_store_x4 (dst + 8, i, r[2]);
 329       aes_block_store_x4 (dst + 12, i, r[3]);
 330 #else
 331 #if __x86_64__
 332       r[0] = u8x16_xor3 (r[0], aes_block_load (src[0] + i), k[0][0]);
 333       r[1] = u8x16_xor3 (r[1], aes_block_load (src[1] + i), k[0][1]);
 334       r[2] = u8x16_xor3 (r[2], aes_block_load (src[2] + i), k[0][2]);
 335       r[3] = u8x16_xor3 (r[3], aes_block_load (src[3] + i), k[0][3]);
 336
 337       for (j = 1; j < rounds; j++)
 338         {
 339           r[0] = aes_enc_round (r[0], k[j][0]);
 340           r[1] = aes_enc_round (r[1], k[j][1]);
 341           r[2] = aes_enc_round (r[2], k[j][2]);
 342           r[3] = aes_enc_round (r[3], k[j][3]);
 343         }
 344
 345       r[0] = aes_enc_last_round (r[0], k[j][0]);
 346       r[1] = aes_enc_last_round (r[1], k[j][1]);
 347       r[2] = aes_enc_last_round (r[2], k[j][2]);
 348       r[3] = aes_enc_last_round (r[3], k[j][3]);
 349
 350       aes_block_store (dst[0] + i, r[0]);
 351       aes_block_store (dst[1] + i, r[1]);
 352       aes_block_store (dst[2] + i, r[2]);
 353       aes_block_store (dst[3] + i, r[3]);
 354 #else
 355       r[0] ^= aes_block_load (src[0] + i);
 356       r[1] ^= aes_block_load (src[1] + i);
 357       r[2] ^= aes_block_load (src[2] + i);
 358       r[3] ^= aes_block_load (src[3] + i);
 359       for (j = 0; j < rounds - 1; j++)
 360         {
 361           r[0] = vaesmcq_u8 (vaeseq_u8 (r[0], k[j][0]));
 362           r[1] = vaesmcq_u8 (vaeseq_u8 (r[1], k[j][1]));
 363           r[2] = vaesmcq_u8 (vaeseq_u8 (r[2], k[j][2]));
 364           r[3] = vaesmcq_u8 (vaeseq_u8 (r[3], k[j][3]));
 365         }
 366       r[0] = vaeseq_u8 (r[0], k[j][0]) ^ k[rounds][0];
 367       r[1] = vaeseq_u8 (r[1], k[j][1]) ^ k[rounds][1];
 368       r[2] = vaeseq_u8 (r[2], k[j][2]) ^ k[rounds][2];
 369       r[3] = vaeseq_u8 (r[3], k[j][3]) ^ k[rounds][3];
 370       aes_block_store (dst[0] + i, r[0]);
 371       aes_block_store (dst[1] + i, r[1]);
 372       aes_block_store (dst[2] + i, r[2]);
 373       aes_block_store (dst[3] + i, r[3]);
 374 #endif
 375 #endif
 376     }
 377
 378   len -= u32xN_splat (count);
 379
 380   for (i = 0; i < N; i++)
 381     {
 382       src[i] += count;
 383       dst[i] += count;
 384     }
 385
 386   if (n_left > 0)
 387     goto more;
 388
 389   if (!u32xN_is_all_zero (len & placeholder_mask))
 390     goto more;
 391
 392   return n_ops;
 393 }
 394
 395
 396 static_always_inline u32
 397 aes_ops_dec_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
 398                      u32 n_ops, aes_key_size_t ks)
 399 {
 400   crypto_native_main_t *cm = &crypto_native_main;
 401   int rounds = AES_KEY_ROUNDS (ks);
 402   vnet_crypto_op_t *op = ops[0];
 403   aes_cbc_key_data_t *kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 404   u32 n_left = n_ops;
 405
 406   ASSERT (n_ops >= 1);
 407
 408 decrypt:
 409 #ifdef __VAES__
 410   vaes_cbc_dec (kd->decrypt_key, (u8x64u *) op->src, (u8x64u *) op->dst,
 411                 (u8x16u *) op->iv, op->len, rounds);
 412 #else
 413   aes_cbc_dec (kd->decrypt_key, (u8x16u *) op->src, (u8x16u *) op->dst,
 414                (u8x16u *) op->iv, op->len, rounds);
 415 #endif
 416   op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 417
 418   if (--n_left)
 419     {
 420       op += 1;
 421       kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 422       goto decrypt;
 423     }
 424
 425   return n_ops;
 426 }
 427
 428 static_always_inline void *
 429 aes_cbc_key_exp (vnet_crypto_key_t * key, aes_key_size_t ks)
 430 {
 431   u8x16 e[15], d[15];
 432   aes_cbc_key_data_t *kd;
 433   kd = clib_mem_alloc_aligned (sizeof (*kd), CLIB_CACHE_LINE_BYTES);
 434   aes_key_expand (e, key->data, ks);
 435   aes_key_enc_to_dec (e, d, ks);
 436   for (int i = 0; i < AES_KEY_ROUNDS (ks) + 1; i++)
 437     {
 438 #if __VAES__
 439       kd->decrypt_key[i] = (u8x64) _mm512_broadcast_i64x2 ((__m128i) d[i]);
 440 #else
 441       kd->decrypt_key[i] = d[i];
 442 #endif
 443       kd->encrypt_key[i] = e[i];
 444     }
 445   return kd;
 446 }
 447
 448 #define foreach_aes_cbc_handler_type _(128) _(192) _(256)
 449
 450 #define _(x) \
 451 static u32 aes_ops_dec_aes_cbc_##x \
 452 (vlib_main_t * vm, vnet_crypto_op_t * ops[], u32 n_ops) \
 453 { return aes_ops_dec_aes_cbc (vm, ops, n_ops, AES_KEY_##x); } \
 454 static u32 aes_ops_enc_aes_cbc_##x \
 455 (vlib_main_t * vm, vnet_crypto_op_t * ops[], u32 n_ops) \
 456 { return aes_ops_enc_aes_cbc (vm, ops, n_ops, AES_KEY_##x); } \
 457 static void * aes_cbc_key_exp_##x (vnet_crypto_key_t *key) \
 458 { return aes_cbc_key_exp (key, AES_KEY_##x); }
 459
 460 foreach_aes_cbc_handler_type;
 461 #undef _
 462
 463 #include <fcntl.h>
 464
 465 clib_error_t *
 466 #ifdef __VAES__
 467 crypto_native_aes_cbc_init_icl (vlib_main_t * vm)
 468 #elif __AVX512F__
 469 crypto_native_aes_cbc_init_skx (vlib_main_t * vm)
 470 #elif __aarch64__
 471 crypto_native_aes_cbc_init_neon (vlib_main_t * vm)
 472 #elif __AVX2__
 473 crypto_native_aes_cbc_init_hsw (vlib_main_t * vm)
 474 #else
 475 crypto_native_aes_cbc_init_slm (vlib_main_t * vm)
 476 #endif
 477 {
 478   crypto_native_main_t *cm = &crypto_native_main;
 479
 480 #define _(x) \
 481   vnet_crypto_register_ops_handler (vm, cm->crypto_engine_index, \
 482                                     VNET_CRYPTO_OP_AES_##x##_CBC_ENC, \
 483                                     aes_ops_enc_aes_cbc_##x); \
 484   vnet_crypto_register_ops_handler (vm, cm->crypto_engine_index, \
 485                                     VNET_CRYPTO_OP_AES_##x##_CBC_DEC, \
 486                                     aes_ops_dec_aes_cbc_##x); \
 487   cm->key_fn[VNET_CRYPTO_ALG_AES_##x##_CBC] = aes_cbc_key_exp_##x;
 488   foreach_aes_cbc_handler_type;
 489 #undef _
 490
 491   return 0;
 492 }
 493
 494 /*
 495  * fd.io coding-style-patch-verification: ON
 496  *
 497  * Local Variables:
 498  * eval: (c-set-style "gnu")
 499  * End:
 500  */